T0CalibrationClassic.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef T0CALIBRATIONCLASSIC_H
#define T0CALIBRATIONCLASSIC_H
 
#include <TF1.h>
#include <TFile.h>
#include <TH1.h>
#include <TH2.h>
 
#include <iostream>
#include <vector>
 
#include "AthenaKernel/getMessageSvc.h"
#include "GaudiKernel/MsgStream.h"
#include "MdtCalibData/MdtTubeFitContainer.h"
#include "MdtCalibData/MdtTubeFullInfoContainer.h"
#include "MdtCalibInterfaces/IMdtCalibration.h"
 
namespace MuonCalib {
 
    class MuonCalibSegment;
    class IMdtCalibrationOutput;

    class T0ClassicSettings {
    public:
        T0ClassicSettings(double minAdc, double maxAdc, int adcBins, double minTime, double maxTime, int timeBins, bool fitTime,
                          int minEntries, int initParam, int numParams, std::array<double, 8> fitParams, double chiMax, int printLevel) :
            m_minAdc(minAdc),
            m_maxAdc(maxAdc),
            m_binAdc(adcBins),
            m_minTime(minTime),
            m_maxTime(maxTime),
            m_binTime(timeBins),
            m_fitTime(fitTime),
            m_entries(minEntries),
            m_initParamFlag(initParam),
            m_numParams(numParams),
            m_params(fitParams),
            m_chi2max(chiMax),
            m_printLevel(printLevel) {}

        double minAdc() const { return m_minAdc; };
        double maxAdc() const { return m_maxAdc; };
        int binAdc() const { return m_binAdc; };
        double minTime() const { return m_minTime; };
        double maxTime() const { return m_maxTime; };
        int binTime() const { return m_binTime; };
        bool fitTime() const { return m_fitTime; };
        int entries() const { return m_entries; };
        int initParamFlag() const { return m_initParamFlag; };
        int numParams() const { return m_numParams; };
        const std::array<double, 8>& params() const { return m_params; };
        double chi2max() const { return m_chi2max; };
        int printLevel() const { return m_printLevel; };
        void print() const {
            MsgStream log(Athena::getMessageSvc(), "T0ClassicSettings");
            log << MSG::INFO << "T0ClassicSettings: " << endmsg;
            log << MSG::INFO << "booking of Adc histos: min max bins " << minAdc() << " " << maxAdc() << " " << binAdc() << endmsg;
            log << MSG::INFO << "booking of Time histos: min max bins " << minTime() << " " << maxTime() << " " << binTime() << endmsg;
            log << MSG::INFO << "fitting of Time histos: active minentries paramflag chi2cut nparams" << fitTime() << " " << entries()
                << " " << initParamFlag() << " " << chi2max() << " " << numParams() << endmsg;
            log << MSG::INFO << "Parameters: " << endmsg;
            for (int i = 0; i < numParams(); i++) { log << MSG::INFO << m_params[i] << endmsg; }
        };
 
    private:
        double m_minAdc;                 
        double m_maxAdc;                 
        int m_binAdc;                    
        double m_minTime;                
        double m_maxTime;                
        int m_binTime;                   
        bool m_fitTime;                  
        int m_entries;                   
        int m_initParamFlag;             
        int m_numParams;                 
        std::array<double, 8> m_params;  
        double m_chi2max;                
        int m_printLevel;                
    };                                   // end class T0ClassicSettings

    class T0ClassicHistos {
    public:
        std::unique_ptr<TH1> time{nullptr};  
        std::unique_ptr<TH1> adc{nullptr};   
                                             // TH2* adc_vs_time;
        int id;                              
    };

    class T0CalibrationClassic : public IMdtCalibration {
    public:
        T0CalibrationClassic(const std::string& name, const T0ClassicSettings* settings);
        ~T0CalibrationClassic();
 
        bool handleSegment(MuonCalibSegment& seg);                   
        void setInput(const IMdtCalibrationOutput* input) override;  
        bool analyse();                                              
        bool converged() const;                                      

        virtual MdtCalibOutputPtr getResults() const override;
        virtual MdtCalibOutputPtr analyseSegments(const MuonSegVec& segs) override;  
 
    private:
        T0ClassicHistos* bookHistos(unsigned int idtube);  
        T0ClassicHistos* getHistos(unsigned int idtube);   
        void doTimeFit(T0ClassicHistos&, MdtTubeFitContainer::SingleTubeFit&,
                       MdtTubeFitContainer::SingleTubeCalib&);                                                        
        void doAdcFit(T0ClassicHistos&, MdtTubeFitContainer::SingleTubeFit&, MdtTubeFitContainer::SingleTubeCalib&);  
        void searchParams(TH1* h, double* p, int np);  
        const T0ClassicSettings* m_settings;           
        bool m_converged;                              
        std::string m_name;                            
        int m_currentItnum;                            
        std::unique_ptr<TFile> m_file{};               
        TDirectory* m_regiondir;                       
 
        std::vector<std::unique_ptr<T0ClassicHistos>> m_histos;  
        std::unique_ptr<MdtTubeFitContainer> m_result;           
        bool m_delete_settings;
 
        // hidden assignment operator and copy constructor
        T0CalibrationClassic& operator=(const T0CalibrationClassic& right) = delete;
        T0CalibrationClassic(const T0CalibrationClassic&) = delete;
    };  // end class T0CalibrationClassic
}  // namespace MuonCalib
 
#endif