ECLDigitCalibratorModule.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2020 - Belle II Collaboration                             *
 *                                                                        *
 * Digit Calibration.                                                     *
 *                                                                        *
 * This  module converts the fitted amplitude into calibrated energy,     *
 * fitted time into calibrated time, and determines the time resolution   *
 * per digit. It furthermore determines the background level by counting  *
 * out of time digits above a certain energy threshold.                   *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Torben Ferber (ferber@physics.ubc.ca) (TF)               *
 *               Chris Hearty (hearty@physics.ubc.ca) (CH)                *
 *               Ewan Hill (ehill@mail.ubc.ca)                            *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
 
// STL
#include <vector>
 
// FRAMEWORK
#include <framework/core/Module.h>
#include <framework/datastore/StoreObjPtr.h>
#include <framework/datastore/StoreArray.h>
#include <framework/database/DBObjPtr.h>
 
#include <ecl/utility/ECLTimingUtilities.h>
 
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();
 
    virtual void initialize() override;
 
    virtual void beginRun() override;
 
    virtual void event() override;
 
    virtual void endRun() override;
 
    virtual void terminate() 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 = 8736;  
    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(); 
    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>(); 
    // For the energy dependence correction to the time
    // t-t0 = p1 + pow( (p3/(amplitude+p2)), p4 ) + p5*exp(-amplitude/p6)      ("Energy dependence equation")
    // Only change the time walk function paramters if they change away from the below dummy values
    double m_energyDependenceTimeOffsetFitParam_p1 = -999;     
    double m_energyDependenceTimeOffsetFitParam_p2 = -999;     
    double m_energyDependenceTimeOffsetFitParam_p3 = -999;     
    double m_energyDependenceTimeOffsetFitParam_p4 = -999;     
    double m_energyDependenceTimeOffsetFitParam_p5 = -999;     
    double m_energyDependenceTimeOffsetFitParam_p6 = -999;     
  };
 
  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