T0CalibrationMT.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef T0CALIBRATIONMT_H
#define T0CALIBRATIONMT_H
 
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
#include <memory>
#include "MdtCalibData/MdtTubeFitContainer.h"
#include "MdtCalibInterfaces/IMdtCalibration.h"
#include "MuonCalibStandAloneBase/NtupleStationId.h"
 
class TH1;
class TFile;
class TDirectory;
 
namespace MuonCalib {
 
    class MuonCalibSegment;
    class IMdtCalibrationOutput;
    class MuonFixedId;
    class T0MTSettings;
    class T0MTHistos;
    class T0ADCHistos;
    class ADCMTHistos;
    class HistogramId;
    class MdtRelativeTubeT0;

    class T0CalibrationMT : public IMdtCalibration {
    public:
 
        T0CalibrationMT(const std::string& name, 
                        std::shared_ptr<const T0MTSettings> settings, 
                        const std::vector<int> &sort_by,
                        const std::vector<int> &adc_sort_by);

        ~T0CalibrationMT();
 
        bool handleSegment(MuonCalibSegment &seg);  
 
        void setInput(const IMdtCalibrationOutput *input) override;  
 
        bool analyse();  
 
        bool converged() const;  

        virtual IMdtCalibration::MdtCalibOutputPtr getResults() const override;
 
        virtual IMdtCalibration::MdtCalibOutputPtr analyseSegments(const MuonSegVec &segs) override;  
 
    private:
        T0MTHistos *getHistos(const MuonFixedId &idtube, unsigned int nr);      
        ADCMTHistos *getADCHistos(const MuonFixedId &idtube, unsigned int nr);  
        bool analyse_tdc(const int &nr, std::map<int, MdtTubeFitContainer::SingleTubeFit> &full,
                         std::map<int, MdtTubeFitContainer::SingleTubeCalib> &st, std::map<int, std::string> &fit_by_map);
        bool analyse_adc(const int &nr, std::map<int, MdtTubeFitContainer::SingleTubeFit> &full,
                         std::map<int, MdtTubeFitContainer::SingleTubeCalib> &st);
 
        void doTimeFit(T0MTHistos *T0h, const std::set<MuonFixedId> &tube_ids, std::map<int, MdtTubeFitContainer::SingleTubeFit> &fim,
                       std::map<int, MdtTubeFitContainer::SingleTubeCalib> &stcm, std::map<int, std::string> &fit_by_map,
                       const std::string &fit_by);  
 
        void doAdcFit(ADCMTHistos *T0h, const std::set<MuonFixedId> &tube_ids, std::map<int, MdtTubeFitContainer::SingleTubeFit> &fim,
                      std::map<int, MdtTubeFitContainer::SingleTubeCalib> &stcm);  
 
        std::shared_ptr<const T0MTSettings> m_settings;  
        bool m_converged;                
        std::string m_name;              
        int m_currentItnum;              
        std::unique_ptr<TFile> m_file;   
        TDirectory *m_regiondir;         
 
        std::vector<std::map<HistogramId, std::unique_ptr<T0MTHistos>>> m_histos;       
        std::vector<std::map<HistogramId, std::unique_ptr<ADCMTHistos>>> m_adc_histos;  
        std::vector<std::map<HistogramId, std::set<MuonFixedId>>> m_tube_ids;
        std::vector<std::map<HistogramId, std::set<MuonFixedId>>> m_adc_tube_ids;
        std::map<int, int> m_nhits_per_tube;                        
        std::map<NtupleStationId, MdtTubeFitContainer *> m_result;  
        std::map<NtupleStationId, MdtRelativeTubeT0> m_rel_tube_t0s;
        const std::vector<int> &m_sort_by;
        const std::vector<int> &m_adc_sort_by;
 
        // hidden assignment operator and copy constructor
        T0CalibrationMT &operator=(const T0CalibrationMT &right) = delete;
        T0CalibrationMT(const T0CalibrationMT &) = delete;
    };
}  // namespace MuonCalib
 
#endif