#include <T0CalibrationMT.h>

Inheritance diagram for MuonCalib::T0CalibrationMT:

Collaboration 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 More...

	~T0CalibrationMT ()
	destructor More...

bool	handleSegment (MuonCalibSegment &seg)
	fill tube spectra More...

void	setInput (const IMdtCalibrationOutput *input) override
	unused More...

bool	analyse ()
	extract parameters from spectra More...

bool	converged () const
	return m_converged More...

virtual IMdtCalibration::MdtCalibOutputPtr	getResults () const override

virtual IMdtCalibration::MdtCalibOutputPtr	analyseSegments (const MuonSegVec &segs) override
	new interface function More...

virtual std::string	name () const
	returns name (region) of instance More...

Private Member Functions
T0MTHistos *	getHistos (const MuonFixedId &idtube, unsigned int nr)
	retrieve pointer for tube idtube histograms More...

ADCMTHistos *	getADCHistos (const MuonFixedId &idtube, unsigned int nr)
	retrieve pointer for tube idtube histograms More...

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 More...

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 More...

T0CalibrationMT &	operator= (const T0CalibrationMT &right)=delete

	T0CalibrationMT (const T0CalibrationMT &)=delete

Private Attributes
std::shared_ptr< const T0MTSettings >	m_settings
	pointer to the settings More...

bool	m_converged
	convergence status More...

std::string	m_name
	calibration region name More...

int	m_currentItnum
	current iteration (always 1?) More...

std::unique_ptr< TFile >	m_file
	pointer to the histogram file More...

TDirectory *	m_regiondir
	pointer to the ROOT directory More...

std::vector< std::map< HistogramId, std::unique_ptr< T0MTHistos > > >	m_histos
	vector of pointers tube histograms More...

std::vector< std::map< HistogramId, std::unique_ptr< ADCMTHistos > > >	m_adc_histos
	vector of pointers tube histograms More...

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 More...

std::map< NtupleStationId, MdtTubeFitContainer * >	m_result
	tube constants More...

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) {
        
         m_settings = std::make_unique<T0MTSettings>();   
         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 56 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 102 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(std::move(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 61 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; }

◆ 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