Implementation of a T0 calibration using the MT approach. More...

#include <T0CalibrationMT.h>

Inheritance diagram for MuonCalib::T0CalibrationMT:

Public Types
using	MuonSegVec = std::vector<std::shared_ptr<MuonCalibSegment>>
using	MuonSegIt = MuonSegVec::iterator
using	MuonSegCit = MuonSegVec::const_iterator
using	MdtCalibOutputPtr = std::shared_ptr<IMdtCalibrationOutput>

Public Member Functions
	T0CalibrationMT (const std::string &name, std::shared_ptr< const T0MTSettings > settings, const std::vector< int > &sort_by, const std::vector< int > &adc_sort_by)
	constructor
	~T0CalibrationMT ()
	destructor
bool	handleSegment (MuonCalibSegment &seg)
	fill tube spectra
void	setInput (const IMdtCalibrationOutput *input) override
	unused
bool	analyse ()
	extract parameters from spectra
bool	converged () const
	return m_converged
virtual IMdtCalibration::MdtCalibOutputPtr	getResults () const override
virtual IMdtCalibration::MdtCalibOutputPtr	analyseSegments (const MuonSegVec &segs) override
	new interface function
virtual std::string	name () const
	returns name (region) of instance

Private Member Functions
T0MTHistos *	getHistos (const MuonFixedId &idtube, unsigned int nr)
	retrieve pointer for tube idtube histograms
ADCMTHistos *	getADCHistos (const MuonFixedId &idtube, unsigned int nr)
	retrieve pointer for tube idtube histograms
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)
	fit time spectrum
void	doAdcFit (ADCMTHistos *T0h, const std::set< MuonFixedId > &tube_ids, std::map< int, MdtTubeFitContainer::SingleTubeFit > &fim, std::map< int, MdtTubeFitContainer::SingleTubeCalib > &stcm)
	fit adc spectrum
T0CalibrationMT &	operator= (const T0CalibrationMT &right)=delete
	T0CalibrationMT (const T0CalibrationMT &)=delete

Private Attributes
std::shared_ptr< const T0MTSettings >	m_settings
	pointer to the settings
bool	m_converged
	convergence status
std::string	m_name
	calibration region name
int	m_currentItnum
	current iteration (always 1?)
std::unique_ptr< TFile >	m_file
	pointer to the histogram file
TDirectory *	m_regiondir
	pointer to the ROOT directory
std::vector< std::map< HistogramId, std::unique_ptr< T0MTHistos > > >	m_histos
	vector of pointers tube histograms
std::vector< std::map< HistogramId, std::unique_ptr< ADCMTHistos > > >	m_adc_histos
	vector of pointers tube histograms
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
	number of hits per tube
std::map< NtupleStationId, MdtTubeFitContainer * >	m_result
	tube constants
std::map< NtupleStationId, MdtRelativeTubeT0 >	m_rel_tube_t0s
const std::vector< int > &	m_sort_by
const std::vector< int > &	m_adc_sort_by

Detailed Description

Implementation of a T0 calibration using the MT approach.

Copied from T0CalibrationClassic

Author: Felix.nosp@m..Rau.nosp@m.scher.nosp@m.@Phy.nosp@m.sik.U.nosp@m.ni-M.nosp@m.uench.nosp@m.en.D.nosp@m.e

Date: June 2005

Definition at line 40 of file T0CalibrationMT.h.

Member Typedef Documentation

◆ MdtCalibOutputPtr

using MuonCalib::IMdtCalibration::MdtCalibOutputPtr = std::shared_ptr<IMdtCalibrationOutput>

inherited

Definition at line 30 of file IMdtCalibration.h.

◆ MuonSegCit

using MuonCalib::IMdtCalibration::MuonSegCit = MuonSegVec::const_iterator

inherited

Definition at line 29 of file IMdtCalibration.h.

◆ MuonSegIt

using MuonCalib::IMdtCalibration::MuonSegIt = MuonSegVec::iterator

inherited

Definition at line 28 of file IMdtCalibration.h.

◆ MuonSegVec

using MuonCalib::IMdtCalibration::MuonSegVec = std::vector<std::shared_ptr<MuonCalibSegment>>

inherited

Definition at line 27 of file IMdtCalibration.h.

Constructor & Destructor Documentation

◆ T0CalibrationMT() [1/2]

MuonCalib::T0CalibrationMT::T0CalibrationMT	(	const std::string &	name,
		std::shared_ptr< const T0MTSettings >	settings,
		const std::vector< int > &	sort_by,
		const std::vector< int > &	adc_sort_by )

constructor

Parameters

[in]	name	of the region/chamber to be calibrated
[in]	pointer	to settings vector
[in]	sorting	criteria (TUBE, CHAMBER, MULTILAYER...) default is by TUBE

Definition at line 32 of file T0CalibrationMT.cxx.

                                                                        :
        IMdtCalibration(name),
        m_settings(settings),
        m_converged(false),
        m_name(name),
        m_currentItnum(0),
        m_sort_by(sort_by),
        m_adc_sort_by(adc_sort_by) {
       
        std::string HistoFileName = "T0MT_" + m_name + ".root";
        m_file = std::make_unique<TFile>(HistoFileName.c_str(), "recreate");
        m_regiondir = m_file->mkdir(m_name.c_str());
 
        m_histos.resize(sort_by.size());
        m_adc_histos.resize(adc_sort_by.size());
 
        m_tube_ids.resize(sort_by.size());
        m_adc_tube_ids.resize(adc_sort_by.size());
    }

◆ ~T0CalibrationMT()

MuonCalib::T0CalibrationMT::~T0CalibrationMT ( )

destructor

Definition at line 55 of file T0CalibrationMT.cxx.

                                      {
        m_file->Write();
        m_file->Close();      
    }

◆ T0CalibrationMT() [2/2]

MuonCalib::T0CalibrationMT::T0CalibrationMT ( const T0CalibrationMT & )

privatedelete

Member Function Documentation

◆ analyse()

bool MuonCalib::T0CalibrationMT::analyse ( )

extract parameters from spectra

Definition at line 101 of file T0CalibrationMT.cxx.

                                  {
        MsgStream log(Athena::getMessageSvc(), "T0CalibrationMT");            
        std::map<int, MdtTubeFitContainer::SingleTubeFit> full;
        std::map<int, MdtTubeFitContainer::SingleTubeCalib> st;
        std::map<int, std::string> fit_by;
        if (m_settings->FitTime()) {
            for (unsigned int i = 0; i < m_sort_by.size(); i++) { analyse_tdc(i, full, st, fit_by); }
        }
        for (unsigned int i = 0; i < m_adc_sort_by.size(); i++) { analyse_adc(i, full, st); }
 
        for (auto & it : full) {
            if (it.first == 0) continue;
            MuonFixedId fId(it.first);
            NtupleStationId sid(fId);
            sid.SetMultilayer(0);
            MdtTubeFitContainer::SingleTubeFit &fi(it.second);
            MdtTubeFitContainer::SingleTubeCalib &stc(st[it.first]);
            fi.group_by = fit_by[it.first];
            int nML = fId.mdtMultilayer();
            int nL = fId.mdtTubeLayer();
            int nT = fId.mdtTube();
            const MdtIdHelper& idHelper{m_result[sid]->idHelperSvc()->mdtIdHelper()};
            const Identifier tubeId = idHelper.channelID(fId.stationNameString(), 
                                                         fId.eta(), fId.phi(), nML, nL, nT);
                 
            bool setInfo = m_result[sid]->setCalib(stc, tubeId, log);
            if (!setInfo) {
                log << MSG::WARNING << "T0CalibrationMT::PROBLEM! could not set SingleTubeCalib info" << endmsg;
            }
            fi.n_hits = m_nhits_per_tube[fId.getIdInt()];
            fi.n_hits_above_adc_cut = m_nhits_per_tube[fId.getIdInt()];
            setInfo = m_result[sid]->setFit(std::move(fi), tubeId, log);
            if (!setInfo) {
                MsgStream log(Athena::getMessageSvc(), "T0CalibrationMT");
                log << MSG::WARNING << "T0CalibrationMT::PROBLEM! could not set SingleTubeFit info" << endmsg;
            }
        }
 
        m_currentItnum++;
        m_file->Write();
        return true;
    }

◆ analyse_adc()

bool MuonCalib::T0CalibrationMT::analyse_adc	(	const int &	nr,
		std::map< int, MdtTubeFitContainer::SingleTubeFit > &	full,
		std::map< int, MdtTubeFitContainer::SingleTubeCalib > &	st )

private

Definition at line 167 of file T0CalibrationMT.cxx.

                                                                                           {
        for (std::map<HistogramId, std::unique_ptr<ADCMTHistos>>::iterator it = m_adc_histos[nr].begin(); it != m_adc_histos[nr].end();
             ++it)
            if (m_settings->FitADC()) { doAdcFit(it->second.get(), m_adc_tube_ids[nr][it->first], full, st); }
        return true;
    }

◆ analyse_tdc()

bool MuonCalib::T0CalibrationMT::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 )

private

Definition at line 144 of file T0CalibrationMT.cxx.

                                                                                                                               {
        if (m_settings->VerboseLevel() > 1) {
            MsgStream log(Athena::getMessageSvc(), "T0CalibrationMT");
            log << MSG::VERBOSE << "T0CalibrationMT::analyse iteration " << m_currentItnum << endmsg;
        }
        std::string fit_by("UNKNOWN");
        switch (m_sort_by[nr]) {
            case HistogramId::TUBE: fit_by = "TUBE"; break;
            case HistogramId::LAYER: fit_by = "LAYER"; break;
            case HistogramId::MULTILAYER: fit_by = "MULTILAYER"; break;
            case HistogramId::CHAMBER: fit_by = "CHAMBER"; break;
            case HistogramId::MEZZ_CARD: fit_by = "MEZZ_CARD"; break;
        }
 
        for (std::map<HistogramId, std::unique_ptr<T0MTHistos>>::iterator it = m_histos[nr].begin(); it != m_histos[nr].end(); ++it)
        // loop over m_histos histograms
        {
            doTimeFit(it->second.get(), m_tube_ids[nr][it->first], full, st, fit_by_map, fit_by);
        }
        return true;
    }

◆ analyseSegments()

IMdtCalibration::MdtCalibOutputPtr MuonCalib::T0CalibrationMT::analyseSegments ( const MuonSegVec & segs )

overridevirtual

new interface function

Implements MuonCalib::IMdtCalibration.

Definition at line 175 of file T0CalibrationMT.cxx.

                                                                                            {
        for (const auto & seg : segs) handleSegment(*seg);
        analyse();
        return getResults();
    }

◆ converged()

bool MuonCalib::T0CalibrationMT::converged ( ) const

return m_converged

Definition at line 300 of file T0CalibrationMT.cxx.

300{ return m_converged; }

◆ doAdcFit()

void MuonCalib::T0CalibrationMT::doAdcFit	(	ADCMTHistos *	T0h,
		const std::set< MuonFixedId > &	tube_ids,
		std::map< int, MdtTubeFitContainer::SingleTubeFit > &	fim,
		std::map< int, MdtTubeFitContainer::SingleTubeCalib > &	stcm )

private

fit adc spectrum

Definition at line 237 of file T0CalibrationMT.cxx.

                                                                                          {
        if (T0h->FitAdc() && m_settings->MinEntriesADC() <= T0h->GetADCSpec()->GetEntries()) {
            const TF1 *fun(T0h->GetAdcFunction());
            if (fun == nullptr) return;
            for (auto tube_id : tube_ids) {
                if (tube_id.getIdInt() == 0) continue;
                MdtTubeFitContainer::SingleTubeFit &fi(fim[tube_id.getIdInt()]);
                MdtTubeFitContainer::SingleTubeCalib &stc(stcm[tube_id.getIdInt()]);
 
                stc.adcCal = fun->GetParameter(1);
                for (int i = 0; (i < fun->GetNpar() && i < 4); i++) {
                    fi.adc_par[i] = fun->GetParameter(i);
                    fi.adc_err[i] = fun->GetParError(i);
                }
                fi.adc_chi2 = fun->GetChisquare() / fun->GetNDF();
            }
        }
    }

◆ doTimeFit()

void MuonCalib::T0CalibrationMT::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 )

private

fit time spectrum

Definition at line 181 of file T0CalibrationMT.cxx.

                                                             {
        TDirectory *cwd = gDirectory;
        m_regiondir->cd();
        // do t0 fit
        MdtRelativeTubeT0::TubeGroup theGroup(MdtRelativeTubeT0::UNKNOWN);
        if (fit_by == "CHAMBER")
            theGroup = MdtRelativeTubeT0::CHAMBER;
        else if (fit_by == "MULTILAYER")
            theGroup = MdtRelativeTubeT0::MULTILAYER;
        else if (fit_by == "LAYER")
            theGroup = MdtRelativeTubeT0::LAYER;
        else if (fit_by == "MEZZ_CARD")
            theGroup = MdtRelativeTubeT0::MEZZ_CARD;
        if (T0h->FitT0() && m_settings->MinEntriesTime() <= T0h->GetTSpec()->GetEntries()) {
            const TF1 *fun(T0h->GetT0Function());
            for (auto tube_id : tube_ids) {
                if (tube_id.getIdInt() == 0) continue;
                NtupleStationId stId(tube_id);
                stId.SetMultilayer(0);
                double rel_t0(0.0);
                if (m_settings->T0Settings()->CorrectRelT0s()) rel_t0 = m_rel_tube_t0s[stId].GetRelativeOffset(tube_id, theGroup);
                MdtTubeFitContainer::SingleTubeFit &fi(fim[tube_id.getIdInt()]);
                MdtTubeFitContainer::SingleTubeCalib &stc(stcm[tube_id.getIdInt()]);
                // store parameters
                fi.statistics = static_cast<int>(T0h->GetTSpec()->GetEntries());
                fi.chi2Tdc = T0h->T0Chi2();
                fi.par[0] = fun->GetParameter(T0MTHistos ::T0_PAR_NR_BACK);
                fi.cov[0] = fun->GetParError(T0MTHistos ::T0_PAR_NR_BACK);
                fi.par[4] = fun->GetParameter(T0MTHistos ::T0_PAR_NR_T0) + rel_t0;
                fi.cov[4] = fun->GetParError(T0MTHistos ::T0_PAR_NR_T0);
                fi.par[6] = fun->GetParameter(T0MTHistos ::T0_PAR_NR_T);
                fi.cov[6] = fun->GetParError(T0MTHistos ::T0_PAR_NR_T);
                stc.t0 = fun->GetParameter(T0MTHistos ::T0_PAR_NR_T0) + rel_t0;
                stc.statusCode = T0h->StatusCode();
                m_converged = true;
                fit_by_map[tube_id.getIdInt()] = fit_by;
            }
        }
        if (T0h->FitTmax() && m_settings->MinEntriesTime() <= T0h->GetTSpec()->GetEntries()) {
            const TF1 *fun(T0h->GetTMaxFunction());
            // store parameters
            for (auto tube_id : tube_ids) {
                if (tube_id.getIdInt() == 0) continue;
                MdtTubeFitContainer::SingleTubeFit &fi(fim[tube_id.getIdInt()]);
                //          MdtTubeFitContainer::SingleTubeCalib &stc(stcm[*it]);
                fi.par[5] = fun->GetParameter(T0MTHistos ::TMAX_PAR_NR_TMAX);
                fi.cov[5] = fun->GetParError(T0MTHistos ::TMAX_PAR_NR_TMAX);
                fi.chi2TdcEnd = fun->GetChisquare() / fun->GetNDF();
            }
        }
        cwd->cd();
    }

◆ getADCHistos()

ADCMTHistos * MuonCalib::T0CalibrationMT::getADCHistos	(	const MuonFixedId &	idtube,
		unsigned int	nr )

private

retrieve pointer for tube idtube histograms

Definition at line 260 of file T0CalibrationMT.cxx.

                                                                                         {
        HistogramId id;
        id.Initialize(idtube, m_adc_sort_by[nr]);
        if (!m_adc_histos[nr][id]) {
            TDirectory *cwd = gDirectory;
            m_regiondir->cd();
            m_adc_histos[nr][id] = std::make_unique<ADCMTHistos>(id.getIdInt(), m_settings.get(), id.HistogramName().c_str());
            cwd->cd();
        }
        m_adc_tube_ids[nr][id].insert(idtube);
        return m_adc_histos[nr][id].get();
    }

◆ getHistos()

T0MTHistos * MuonCalib::T0CalibrationMT::getHistos	(	const MuonFixedId &	idtube,
		unsigned int	nr )

private

retrieve pointer for tube idtube histograms

Definition at line 273 of file T0CalibrationMT.cxx.

                                                                                     {
        HistogramId id;
        id.Initialize(idtube, m_sort_by[nr]);
        if (!m_histos[nr][id]) {
            TDirectory *cwd = gDirectory;
            m_regiondir->cd();
            m_histos[nr][id] = std::make_unique<T0MTHistos>(id.getIdInt(), m_settings.get(), id.HistogramName().c_str());
            cwd->cd();
        }
        m_tube_ids[nr][id].insert(idtube);
        return m_histos[nr][id].get();
    }

◆ getResults()

IMdtCalibration::MdtCalibOutputPtr MuonCalib::T0CalibrationMT::getResults ( ) const

overridevirtual

Returns: the calibration results

Implements MuonCalib::IMdtCalibration.

Definition at line 258 of file T0CalibrationMT.cxx.

258{ return std::make_shared<T0CalibrationOutput>(m_result); }

◆ handleSegment()

bool MuonCalib::T0CalibrationMT::handleSegment ( MuonCalibSegment & seg )

fill tube spectra

Definition at line 60 of file T0CalibrationMT.cxx.

                                                             {
        for (const MuonCalibSegment::MdtHitPtr& hit : seg.mdtHOT()) {
            MuonFixedId id = hit->identify();
            m_nhits_per_tube[id.getIdInt()]++;
            // get the T0 originally subtracted for this hit
            int nML = id.mdtMultilayer();
            int nL = id.mdtTubeLayer();
            int nT = id.mdtTube();
            const MdtTubeFitContainer::SingleTubeCalib *stc(nullptr);
            NtupleStationId sid(id);
            sid.SetMultilayer(0);
            std::map<NtupleStationId, MdtTubeFitContainer *>::const_iterator res_it(m_result.find(sid));
            if (res_it != m_result.end()) {
                const MdtIdHelper& idHelper{res_it->second->idHelperSvc()->mdtIdHelper()};
                const Identifier tubeId = idHelper.channelID(id.stationNameString(), 
                                                             id.eta(), id.phi(), nML, nL, nT);
                stc = res_it->second->getCalib(tubeId);
            }
            double oldT0 = 0;
            if (stc)
                oldT0 = stc->t0;
            else {
                MsgStream log(Athena::getMessageSvc(), "T0CalibrationMT");
                log << MSG::WARNING << "no Single Tube Calib info found for ML=" << nML << " L=" << nL << " T=" << nT << endmsg;
            }
 
            // get histos
            for (unsigned int i = 0; i < m_sort_by.size(); i++) {
                T0MTHistos *histos = getHistos(id, i);
                histos->GetTSpec()->Fill(hit->driftTime() + oldT0 + hit->tubeT0());
            }
            for (unsigned int i = 0; i < m_adc_sort_by.size(); i++) {
                ADCMTHistos *adc_histos = getADCHistos(id, i);
                adc_histos->GetADCSpec()->Fill(hit->adcCount());
            }
            // relative t0 offsets
            m_rel_tube_t0s[sid].AddHit(*hit);
        }
        return true;
    }

◆ name()

virtual std::string MuonCalib::IMdtCalibration::name ( ) const

inlinevirtualinherited

returns name (region) of instance

Definition at line 49 of file IMdtCalibration.h.

49{ return m_name; }

MuonCalib::IMdtCalibration::m_name

std::string m_name

Definition IMdtCalibration.h:52

◆ operator=()

T0CalibrationMT & MuonCalib::T0CalibrationMT::operator= ( const T0CalibrationMT & right )

privatedelete

◆ setInput()

void MuonCalib::T0CalibrationMT::setInput ( const IMdtCalibrationOutput * input )

overridevirtual

unused

Implements MuonCalib::IMdtCalibration.

Definition at line 286 of file T0CalibrationMT.cxx.

                                                                        {
        // This method is called both by the event loop and by the tool.
        // Only the call from the tool is relevant for this implementation
        // and should be performed only once.
 
        if (m_result.size()) return;
 
        const T0CalibrationOutput *t0Input = dynamic_cast<const T0CalibrationOutput *>(calib_in);
        if (!calib_in || !t0Input) return;
        m_result = t0Input->GetMap();
        for (auto & it : m_result)
            it.second->setImplementation("T0CalibrationMT");
    }

Member Data Documentation

◆ m_adc_histos

std::vector<std::map<HistogramId, std::unique_ptr<ADCMTHistos> > > MuonCalib::T0CalibrationMT::m_adc_histos

private

vector of pointers tube histograms

Definition at line 93 of file T0CalibrationMT.h.

◆ m_adc_sort_by

const std::vector<int>& MuonCalib::T0CalibrationMT::m_adc_sort_by

private

Definition at line 100 of file T0CalibrationMT.h.

◆ m_adc_tube_ids

std::vector<std::map<HistogramId, std::set<MuonFixedId> > > MuonCalib::T0CalibrationMT::m_adc_tube_ids

private

Definition at line 95 of file T0CalibrationMT.h.

◆ m_converged

bool MuonCalib::T0CalibrationMT::m_converged

private

convergence status

Definition at line 86 of file T0CalibrationMT.h.

◆ m_currentItnum

int MuonCalib::T0CalibrationMT::m_currentItnum

private

current iteration (always 1?)

Definition at line 88 of file T0CalibrationMT.h.

◆ m_file

std::unique_ptr<TFile> MuonCalib::T0CalibrationMT::m_file

private

pointer to the histogram file

Definition at line 89 of file T0CalibrationMT.h.

◆ m_histos

std::vector<std::map<HistogramId, std::unique_ptr<T0MTHistos> > > MuonCalib::T0CalibrationMT::m_histos

private

vector of pointers tube histograms

Definition at line 92 of file T0CalibrationMT.h.

◆ m_name

std::string MuonCalib::T0CalibrationMT::m_name

private

calibration region name

Definition at line 87 of file T0CalibrationMT.h.

◆ m_nhits_per_tube

std::map<int, int> MuonCalib::T0CalibrationMT::m_nhits_per_tube

private

number of hits per tube

Definition at line 96 of file T0CalibrationMT.h.

◆ m_regiondir

TDirectory* MuonCalib::T0CalibrationMT::m_regiondir

private

pointer to the ROOT directory

Definition at line 90 of file T0CalibrationMT.h.

◆ m_rel_tube_t0s

std::map<NtupleStationId, MdtRelativeTubeT0> MuonCalib::T0CalibrationMT::m_rel_tube_t0s

private

Definition at line 98 of file T0CalibrationMT.h.

◆ m_result

std::map<NtupleStationId, MdtTubeFitContainer *> MuonCalib::T0CalibrationMT::m_result

private

tube constants

Definition at line 97 of file T0CalibrationMT.h.

◆ m_settings

std::shared_ptr<const T0MTSettings> MuonCalib::T0CalibrationMT::m_settings

private

pointer to the settings

Definition at line 85 of file T0CalibrationMT.h.

◆ m_sort_by

const std::vector<int>& MuonCalib::T0CalibrationMT::m_sort_by

private

Definition at line 99 of file T0CalibrationMT.h.

◆ m_tube_ids

std::vector<std::map<HistogramId, std::set<MuonFixedId> > > MuonCalib::T0CalibrationMT::m_tube_ids

private

Definition at line 94 of file T0CalibrationMT.h.

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ MdtCalibOutputPtr

◆ MuonSegCit

◆ MuonSegIt

◆ MuonSegVec

Constructor & Destructor Documentation

◆ T0CalibrationMT() [1/2]

◆ ~T0CalibrationMT()

◆ T0CalibrationMT() [2/2]

Member Function Documentation

◆ analyse()

◆ analyse_adc()

◆ analyse_tdc()

◆ analyseSegments()

◆ converged()

◆ doAdcFit()

◆ doTimeFit()

◆ getADCHistos()

◆ getHistos()

◆ getResults()

◆ handleSegment()

◆ name()

◆ operator=()

◆ setInput()

Member Data Documentation

◆ m_adc_histos

◆ m_adc_sort_by

◆ m_adc_tube_ids

◆ m_converged

◆ m_currentItnum

◆ m_file

◆ m_histos

◆ m_name

◆ m_nhits_per_tube

◆ m_regiondir

◆ m_rel_tube_t0s

◆ m_result

◆ m_settings

◆ m_sort_by

◆ m_tube_ids