MuonCalib::MdtCalibDataContainer Class Reference

#include <MdtCalibDataContainer.h>

Collaboration diagram for MuonCalib::MdtCalibDataContainer:

Public Types
enum	RegionGranularity { RegionGranularity::OneRt, RegionGranularity::OnePerChamber, RegionGranularity::OnePerMultiLayer }
using	CorrectionPtr = MdtFullCalibData::CorrectionPtr
using	RtRelationPtr = MdtFullCalibData::RtRelationPtr
using	TubeContainerPtr = MdtFullCalibData::TubeContainerPtr

Public Member Functions
	MdtCalibDataContainer (const Muon::IMuonIdHelperSvc *idHelprSvc, const RegionGranularity granularity)
	~MdtCalibDataContainer ()=default
const MdtFullCalibData *	getCalibData (const Identifier &measId, MsgStream &msg) const
	Returns the calibration data associated with this station More...
bool	hasDataForChannel (const Identifier &measId, MsgStream &msg) const
	Checks whether a calibration data object is already present. More...
bool	storeData (const Identifier &mlID, CorrectionPtr corrFuncSet, MsgStream &msg)
bool	storeData (const Identifier &mlID, RtRelationPtr rtRelation, MsgStream &msg)
bool	storeData (const Identifier &mlID, TubeContainerPtr tubeContainer, MsgStream &msg)
RegionGranularity	granularity () const
void	setInversePropSpeed (const float speed)
float	inversePropSpeed () const

Private Member Functions
std::optional< unsigned int >	containerIndex (const Identifier &measId, MsgStream &msg) const

Private Attributes
const Muon::IMuonIdHelperSvc *	m_idHelperSvc {nullptr}
const RegionGranularity	m_granularity {RegionGranularity::OneRt}
const MdtIdHelper &	m_idHelper {m_idHelperSvc->mdtIdHelper()}
std::vector< MdtFullCalibData >	m_dataCache {}
float	m_invPropSpeed {0.f}

Detailed Description

Definition at line 20 of file MdtCalibDataContainer.h.

Member Typedef Documentation

CorrectionPtr

using MuonCalib::MdtCalibDataContainer::CorrectionPtr = MdtFullCalibData::CorrectionPtr

Definition at line 22 of file MdtCalibDataContainer.h.

RtRelationPtr

using MuonCalib::MdtCalibDataContainer::RtRelationPtr = MdtFullCalibData::RtRelationPtr

Definition at line 23 of file MdtCalibDataContainer.h.

TubeContainerPtr

using MuonCalib::MdtCalibDataContainer::TubeContainerPtr = MdtFullCalibData::TubeContainerPtr

Definition at line 24 of file MdtCalibDataContainer.h.

Member Enumeration Documentation

RegionGranularity

enum MuonCalib::MdtCalibDataContainer::RegionGranularity

strong

Enumerator
OneRt
OnePerChamber
OnePerMultiLayer

Definition at line 26 of file MdtCalibDataContainer.h.

{ OneRt, OnePerChamber, OnePerMultiLayer };

Constructor & Destructor Documentation

MdtCalibDataContainer()

MuonCalib::MdtCalibDataContainer::MdtCalibDataContainer	(	const Muon::IMuonIdHelperSvc *	idHelprSvc,
		const RegionGranularity	granularity
	)

Definition at line 8 of file MdtCalibDataContainer.cxx.

                                                                  :
        m_idHelperSvc{idHelperSvc},
        m_granularity{granularity} {
}

~MdtCalibDataContainer()

MuonCalib::MdtCalibDataContainer::~MdtCalibDataContainer ( )

default

Member Function Documentation

containerIndex()

std::optional< unsigned int > MuonCalib::MdtCalibDataContainer::containerIndex ( const Identifier &  measId, MsgStream &  msg  ) const

inlineprivate

Definition at line 17 of file MdtCalibDataContainer.cxx.

                                                                                                                      {
     IdentifierHash hash{0};
      
    if (m_granularity == RegionGranularity::OnePerMultiLayer && 
        (m_idHelper.get_detectorElement_hash(measId, hash) ||
         m_idHelper.detectorElement_hash_max() < static_cast<unsigned int>(hash))) {
        msg<<MSG::ERROR <<__FILE__<<":"<<__LINE__<<" Failed to look up a proper detector element hash for "
                        <<m_idHelperSvc->toString(measId)<<endmsg;
        return std::nullopt;
    } else if (m_granularity == RegionGranularity::OnePerChamber &&
               (m_idHelper.get_module_hash(measId, hash) ||
                m_idHelper.module_hash_max() < static_cast<unsigned int>(hash))) {
        msg<<MSG::ERROR <<__FILE__<<":"<<__LINE__<<" Failed to look up a proper detector element hash for "
                        <<m_idHelperSvc->toString(measId)<<endmsg;
        return std::nullopt;
    }
    return std::make_optional<unsigned int>(static_cast<unsigned int>(hash));
}

getCalibData()

const MdtFullCalibData * MuonCalib::MdtCalibDataContainer::getCalibData	(	const Identifier &	measId,
		MsgStream &	msg
	)		const

Returns the calibration data associated with this station

Definition at line 41 of file MdtCalibDataContainer.cxx.

                                                                                                          {
    std::optional<unsigned int> index = containerIndex(measId, msg);
    if (!index) return nullptr;
    if ((*index ) < m_dataCache.size()) {
        const MdtFullCalibData& data = m_dataCache[*index];
        if (data) {return &data;}
    }
    msg<<MSG::WARNING<<__FILE__<<":"<<__LINE__<<" No Mdt calibration data is stored for "
                     <<m_idHelperSvc->toString(measId)<<endmsg;
    return nullptr;
}

granularity()

MdtCalibDataContainer::RegionGranularity MuonCalib::MdtCalibDataContainer::granularity

(

)

const

Definition at line 16 of file MdtCalibDataContainer.cxx.

{ return m_granularity; }

hasDataForChannel()

bool MuonCalib::MdtCalibDataContainer::hasDataForChannel	(	const Identifier &	measId,
		MsgStream &	msg
	)		const

Checks whether a calibration data object is already present.

Definition at line 36 of file MdtCalibDataContainer.cxx.

                                                                                            {
    std::optional<unsigned int > index = containerIndex(measId, msg);
    return !(!index || (*index) >= m_dataCache.size() || !m_dataCache[*index]);
}

inversePropSpeed()

float MuonCalib::MdtCalibDataContainer::inversePropSpeed

(

)

const

Definition at line 14 of file MdtCalibDataContainer.cxx.

{ return m_invPropSpeed; }

setInversePropSpeed()

void MuonCalib::MdtCalibDataContainer::setInversePropSpeed

(

const float

speed

)

Definition at line 13 of file MdtCalibDataContainer.cxx.

{m_invPropSpeed = speed; }

storeData() [1/3]

bool MuonCalib::MdtCalibDataContainer::storeData	(	const Identifier &	mlID,
		CorrectionPtr	corrFuncSet,
		MsgStream &	msg
	)

Check for a valid index

Resize the container if neccessary

Definition at line 52 of file MdtCalibDataContainer.cxx.

                                                                                                       {
    std::optional<unsigned int> index = containerIndex(mlID, msg);
    if (!index) return false;
    if (!corrFuncSet) {
        msg << MSG::ERROR<<__FILE__<<":"<<__LINE__<<" No correction functional set parsed for multilayer "
            <<m_idHelperSvc->toString(mlID) << endmsg;
        return false;
    }
    if (m_dataCache.size() <= (*index)) m_dataCache.resize(*index + 1);
    MdtFullCalibData& cache = m_dataCache[*index];
    if (cache.corrections && cache.corrections != corrFuncSet) {
        msg << MSG::ERROR<<__FILE__<<":"<<__LINE__<<" There already exist a rt relation object for multilayer "
            <<m_idHelperSvc->toString(mlID) << endmsg;
        return false;
    }
    cache.corrections = std::move(corrFuncSet);
    
    if (msg.level() <= MSG::DEBUG) {
         msg << MSG::DEBUG<<__FILE__<<":"<<__LINE__<<" Added successfully the rt corrections for "
             << m_idHelperSvc->toString(mlID)<<endmsg;
    }
    return true;
}

storeData() [2/3]

bool MuonCalib::MdtCalibDataContainer::storeData	(	const Identifier &	mlID,
		RtRelationPtr	rtRelation,
		MsgStream &	msg
	)

Check for a valid index

Resize the container if neccessary

Definition at line 77 of file MdtCalibDataContainer.cxx.

                                                                                                      {
    std::optional<unsigned int> index = containerIndex(mlID, msg);
    if (!index) return false;
    if (!rtRelation) {
        msg << MSG::ERROR<<__FILE__<<":"<<__LINE__<<" No rt relation parsed for multilayer "
            <<m_idHelperSvc->toString(mlID) << endmsg;
        return false;
    }
    if (m_dataCache.size() <= (*index)) m_dataCache.resize(*index + 1);
    MdtFullCalibData& cache = m_dataCache[*index];
    if (cache.rtRelation && cache.rtRelation != rtRelation) {
        msg << MSG::ERROR<<__FILE__<<":"<<__LINE__<<" There already exist a rt relation object for multilayer "
            <<m_idHelperSvc->toString(mlID) << endmsg;
        return false;
    }
    cache.rtRelation = std::move(rtRelation);
 
    if (msg.level() <= MSG::DEBUG) {
         msg << MSG::DEBUG<<__FILE__<<":"<<__LINE__<<" Added successfully the rt relations for "
             << m_idHelperSvc->toString(mlID)<<endmsg;
    }    
    return true;
}

storeData() [3/3]

bool MuonCalib::MdtCalibDataContainer::storeData	(	const Identifier &	mlID,
		TubeContainerPtr	tubeContainer,
		MsgStream &	msg
	)

Check for a valid index

Resize the container if neccessary

Definition at line 102 of file MdtCalibDataContainer.cxx.

                                                                                                           {
    std::optional<unsigned int> index = containerIndex(mlID, msg);
    if (!index) return false;
    if (!tubeContainer) {
        msg << MSG::ERROR<<__FILE__<<":"<<__LINE__<<" No tube ontainer parsed for multilayer "
            <<m_idHelperSvc->toString(mlID) << endmsg;
        return false;
    }
 
    if (m_dataCache.size() <= (*index)) m_dataCache.resize(*index + 1);
    MdtFullCalibData& cache = m_dataCache[*index];
    if (cache.tubeCalib && cache.tubeCalib != tubeContainer) {
        msg << MSG::ERROR<<__FILE__<<":"<<__LINE__<<" There already exist a tube calibration container for multilayer "
            <<m_idHelperSvc->toString(mlID) << endmsg;
        return false;
    }
    if (msg.level() <= MSG::DEBUG) {
         msg << MSG::DEBUG<<__FILE__<<":"<<__LINE__<<" Added successfully the tube calibrations for "
             << m_idHelperSvc->toString(mlID)<<endmsg;
    }
    cache.tubeCalib = tubeContainer;
    if (m_granularity == RegionGranularity::OneRt || 
        m_idHelper.multilayer(mlID) == 2 || 
        m_idHelper.numberOfMultilayers(mlID) == 1) return true;
    return storeData(m_idHelper.multilayerID(mlID, 2), tubeContainer, msg);
}

Member Data Documentation

m_dataCache

std::vector<MdtFullCalibData> MuonCalib::MdtCalibDataContainer::m_dataCache {}

private

Definition at line 53 of file MdtCalibDataContainer.h.

m_granularity

const RegionGranularity MuonCalib::MdtCalibDataContainer::m_granularity {RegionGranularity::OneRt}

private

Definition at line 51 of file MdtCalibDataContainer.h.

m_idHelper

const MdtIdHelper& MuonCalib::MdtCalibDataContainer::m_idHelper {m_idHelperSvc->mdtIdHelper()}

private

Definition at line 52 of file MdtCalibDataContainer.h.

m_idHelperSvc

const Muon::IMuonIdHelperSvc* MuonCalib::MdtCalibDataContainer::m_idHelperSvc {nullptr}

private

Definition at line 50 of file MdtCalibDataContainer.h.

m_invPropSpeed

float MuonCalib::MdtCalibDataContainer::m_invPropSpeed {0.f}

private

Definition at line 54 of file MdtCalibDataContainer.h.

---

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

• MdtCalibDataContainer.h
• MdtCalibDataContainer.cxx