ECLDigitCalibratorModule.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/dataobjects/ECLElementNumbers.h>
#include <ecl/utility/ECLTimingUtilities.h>
 
/* Basf2 headers. */
#include <framework/core/Module.h>
#include <framework/database/DBObjPtr.h>
#include <framework/datastore/StoreArray.h>
#include <framework/datastore/StoreObjPtr.h>
 
/* C++ headers. */
#include <vector>
 
class TH1F;
class TFile;
 
namespace Belle2 {
 
  class EventLevelClusteringInfo;
 
  class ECLCrystalCalib;
  class ECLDigit;
  class ECLDsp;
  class ECLCalDigit;
  class ECLPureCsIInfo;

  class ECLDigitCalibratorModule : public Module {
 
  public:

    ECLDigitCalibratorModule();

    ~ECLDigitCalibratorModule() override;

    virtual void initialize() override;

    virtual void beginRun() override;

    virtual void event() override;

    virtual const char* eclDigitArrayName() const
    { return "ECLDigits" ; }

    virtual const char* eclDspArrayName() const
    { return "ECLDsps" ; }

    virtual const char* eclCalDigitArrayName() const
    { return "ECLCalDigits" ; }

    virtual const char* eventLevelClusteringInfoName() const
    { return "EventLevelClusteringInfo" ; }

    virtual const char* eclPureCsIInfoArrayName() const
    { return "ECLPureCsIInfo" ; }
 
  protected:
 
  private:
 
    double m_backgroundEnergyCut;  
    double m_backgroundTimingCut;  
 
    const int c_nCrystals = ECLElementNumbers::c_NCrystals;  
 
    std::vector < float > v_calibrationCrystalElectronics;  
    std::vector < float > v_calibrationCrystalElectronicsUnc;  
    DBObjPtr<ECLCrystalCalib> m_calibrationCrystalElectronics;  
 
    std::vector < float > v_calibrationCrystalEnergy;  
    std::vector < float > v_calibrationCrystalEnergyUnc;  
    DBObjPtr<ECLCrystalCalib> m_calibrationCrystalEnergy;  
 
    std::vector < float > v_calibrationCrystalElectronicsTime;  
    std::vector < float >
    v_calibrationCrystalElectronicsTimeUnc;  
    DBObjPtr<ECLCrystalCalib> m_calibrationCrystalElectronicsTime;  
 
    std::vector < float > v_calibrationCrystalTimeOffset;  
    std::vector < float > v_calibrationCrystalTimeOffsetUnc;  
    DBObjPtr<ECLCrystalCalib> m_calibrationCrystalTimeOffset;  
 
    std::vector < float > v_calibrationCrateTimeOffset;  
    std::vector < float > v_calibrationCrateTimeOffsetUnc;  
    DBObjPtr<ECLCrystalCalib> m_calibrationCrateTimeOffset;  
 
    std::vector < float > v_calibrationCrystalFlightTime;  
    std::vector < float > v_calibrationCrystalFlightTimeUnc;  
    DBObjPtr<ECLCrystalCalib> m_calibrationCrystalFlightTime;  
 
    StoreObjPtr <EventLevelClusteringInfo> m_eventLevelClusteringInfo; 
 
    StoreArray<ECLDigit> m_eclDigits; 
    StoreArray<ECLCalDigit> m_eclCalDigits; 
    StoreArray<ECLDsp> m_eclDsps; 
    StoreArray<ECLPureCsIInfo> m_eclPureCsIInfo; 
 
    double m_timeInverseSlope; 
 
    double m_pureCsIEnergyCalib = 0.00005; 
    double m_pureCsITimeCalib = 10.; 
    double m_pureCsITimeOffset = 0.31; 
 
    void initializeCalibration(); 
    static void callbackCalibration(DBObjPtr<ECLCrystalCalib>& cal, std::vector<float>& constants,
                                    std::vector<float>& constantsUnc); 
 
    double getT99(const int cellid, const double energy, const bool fitfailed, const int bgcount) const; 
    int determineBackgroundECL(); 
 
    const double c_timeResolutionForFitFailed  = 1.0e9; 
    const double c_timeForFitFailed            = 0.0; 
 
    // new time calibration from Kim and Chris
    std::string m_fileBackgroundName; 
    TFile* m_fileBackground{nullptr}; 
    TH1F* m_th1fBackground{nullptr}; 
 
    const double c_pol2Var1 = 1684.0; 
    const double c_pol2Var2 = 3080.0; 
    const double c_pol2Var3 = -613.9; 
    double m_pol2Max; 
    const int c_nominalBG = 183; 
    double m_averageBG; 
    const double c_minT99 = 3.5; 
 
    bool m_simulatePure = 0; 
 
 
    std::unique_ptr< Belle2::ECL::ECLTimingUtilities > ECLTimeUtil =
      std::make_unique<Belle2::ECL::ECLTimingUtilities>(); 
 
    bool m_isMC = false; 
 
  };

  class ECLDigitCalibratorPureCsIModule : public ECLDigitCalibratorModule {
  public:
    virtual const char* eclDigitArrayName() const override
    { return "ECLDigitsPureCsI" ; }

    virtual const char* eclCalDigitArrayName() const override
    { return "ECLCalDigitsPureCsI" ; }

    virtual const char* eclDspArrayName() const override
    { return "ECLDspsPureCsI" ; }

    virtual const char* eventLevelClusteringInfoName() const override
    { return "EventLevelClusteringInfoPureCsI" ; }
 
  };

} // end Belle2 namespace