#include <MdtRdoToPrepDataToolMT.h>

Inheritance diagram for Muon::MdtRdoToPrepDataToolMT:

Collaboration diagram for Muon::MdtRdoToPrepDataToolMT:

Classes
struct	ConvCache
	Helper struct to parse the event data around the tool. More...

Public Member Functions
	MdtRdoToPrepDataToolMT (const std::string &, const std::string &, const IInterface *)

virtual	~MdtRdoToPrepDataToolMT ()=default
	default destructor More...

virtual StatusCode	initialize () override
	standard Athena-Algorithm method More...

virtual StatusCode	decode (const EventContext &ctx, const std::vector< IdentifierHash > &idVect) const override
	Decode method - declared in Muon::IMuonRdoToPrepDataTool. More...

virtual StatusCode	provideEmptyContainer (const EventContext &ctx) const override

virtual StatusCode	decode (const EventContext &ctx, const std::vector< uint32_t > &robIds) const override

Protected Member Functions
void	printPrepDataImpl (const Muon::MdtPrepDataContainer *mdtPrepDataContainer) const

Muon::MdtDriftCircleStatus	getMdtTwinPosition (const MdtDigit &prompt_digit, const MdtDigit &twin_digit, double &radius, double &errRadius, double &zTwin, double &errZTwin, bool &twinIsPrompt) const
	method to get the twin tube 2nd coordinate More...

StatusCode	processCsm (const EventContext &ctx, ConvCache &mdtPrepDataContainer, const MdtCsm *rdoColl) const

StatusCode	processCsmTwin (const EventContext &ctx, ConvCache &mdtPrepDataContainer, const MdtCsm *rdoColll) const

std::unique_ptr< MdtPrepData >	createPrepData (const MdtCalibInput &calibInput, const MdtCalibOutput &calibOutput, ConvCache &cache) const
	Creates the PRD object. More...

ConvCache	setupMdtPrepDataContainer (const EventContext &ctx) const
	Creates the prep data container to be written. More...

const MdtCsmContainer *	getRdoContainer (const EventContext &ctx) const
	Loads the input RDO container from StoreGate. More...

void	processPRDHashes (const EventContext &ctx, ConvCache &mdtPrepDataContainer, const std::vector< IdentifierHash > &chamberHashInRobs) const

bool	handlePRDHash (const EventContext &ctx, ConvCache &mdtPrepDataContainer, IdentifierHash rdoHash) const

void	initDeadChannels (const MuonGM::MdtReadoutElement *mydetEl)

Protected Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

ToolHandle< IMdtCalibrationTool >	m_calibrationTool {this, "CalibrationTool", "MdtCalibrationTool"}
	MDT calibration service. More...

Gaudi::Property< bool >	m_useNewGeo

const MuonGMR4::MuonDetectorManager *	m_detMgrR4 {nullptr}

SG::ReadHandleKey< ActsGeometryContext >	m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "Stored alignment"}

SG::WriteHandleKey< Muon::MdtPrepDataContainer >	m_mdtPrepDataContainerKey {this, "OutputCollection", "MDT_DriftCircles"}
	MdtPrepRawData containers. More...

SG::ReadHandleKey< MdtCsmContainer >	m_rdoContainerKey {this, "RDOContainer", "MDTCSM"}

Gaudi::Property< int >	m_adcCut
	member variables for algorithm properties: More...

Gaudi::Property< bool >	m_calibratePrepData {this, "CalibratePrepData", true}
	toggle on/off calibration of MdtPrepData More...

Gaudi::Property< bool >	m_decodeData {this, "DecodeData", true}
	toggle on/off the decoding of MDT RDO into MdtPrepData More...

bool	m_sortPrepData = false
	Toggle on/off the sorting of the MdtPrepData. More...

ToolHandle< Muon::IMDT_RDO_Decoder >	m_mdtDecoder {this, "Decoder", "Muon::MdtRDO_Decoder/MdtRDO_Decoder"}

bool	m_BMGpresent {false}

int	m_BMGid {-1}

Gaudi::Property< bool >	m_useTwin {this, "UseTwin", true}

Gaudi::Property< bool >	m_discardSecondaryHitTwin {this, "DiscardSecondaryHitTwin", false}

SG::ReadCondHandleKey< TwinTubeMap >	m_twinTubeKey {this, "TwinTubeKey", "MdtTwinTubeMap"}

std::unordered_set< Identifier >	m_DeadChannels {}

SG::ReadCondHandleKey< MuonMDT_CablingMap >	m_readKey {this, "ReadKey", "MuonMDT_CablingMap", "Key of MuonMDT_CablingMap"}

SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_muDetMgrKey

SG::UpdateHandleKey< MdtPrepDataCollection_Cache >	m_prdContainerCacheKey
	This is the key for the cache for the MDT PRD containers, can be empty. More...

SG::WriteHandleKey< xAOD::MdtDriftCircleContainer >	m_xAODKey {this, "xAODKey", "", "If empty, do not produce xAOD, otherwise this is the key of the output xAOD MDT PRD container"}

SG::WriteHandleKey< xAOD::MdtTwinDriftCircleContainer >	m_xAODTwinKey {this, "xAODTwinKey", "", "If empty, do not produce xAOD, otherwise this is the key of the output xAOD MDT PRD container"}

Detailed Description

Tool to produce MDT PRDs

Definition at line 40 of file MdtRdoToPrepDataToolMT.h.

Constructor & Destructor Documentation

◆ MdtRdoToPrepDataToolMT()

Muon::MdtRdoToPrepDataToolMT::MdtRdoToPrepDataToolMT	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

Definition at line 144 of file MdtRdoToPrepDataToolMT.cxx.

144 :

145 base_class(t, n, p) {}

◆ ~MdtRdoToPrepDataToolMT()

virtual Muon::MdtRdoToPrepDataToolMT::~MdtRdoToPrepDataToolMT ( )

virtualdefault

default destructor

Member Function Documentation

◆ createPrepData()

std::unique_ptr< MdtPrepData > Muon::MdtRdoToPrepDataToolMT::createPrepData	(	const MdtCalibInput &	calibInput,
		const MdtCalibOutput &	calibOutput,
		ConvCache &	cache
	)		const

protected

Creates the PRD object.

Test by how much do we break frozen Tier0

Definition at line 290 of file MdtRdoToPrepDataToolMT.cxx.

                                                                                                 {
         if (calibInput.adc() < m_adcCut ||
             calibOutput.status() == MdtDriftCircleStatus::MdtStatusUnDefined) {
             ATH_MSG_VERBOSE("Do not create calib hit for "<<m_idHelperSvc->toString(calibInput.identify())
                             <<", adc: "<<calibInput.adc()<<" vs. "<<m_adcCut<<", calibration bailed out "
                           <<(calibOutput.status() == MdtDriftCircleStatus::MdtStatusUnDefined? "si": "no"));
             return nullptr;
         }
         const MuonGM::MdtReadoutElement* descriptor = calibInput.legacyDescriptor();
         if (!descriptor) {
             if (!cache.legacyDetMgr) {
                 return nullptr;
             }
             descriptor = cache.legacyDetMgr->getMdtReadoutElement(calibInput.identify());
         }
         ATH_MSG_VERBOSE("Calibrated prepdata "<<m_idHelperSvc->toString(calibInput.identify())
                         <<std::endl<<calibInput<<std::endl<<calibOutput);
  
         Amg::Vector2D driftRadius{Amg::Vector2D::Zero()};
         Amg::MatrixX cov(1, 1);
         if (calibOutput.status() == MdtDriftCircleStatus::MdtStatusDriftTime){
             const float r =  calibOutput.driftRadius();
             const float sigR = calibOutput.driftRadiusUncert();
             driftRadius[0] = r; 
             (cov)(0, 0) = sigR * sigR;
         } else (cov)(0, 0) = std::pow(descriptor->innerTubeRadius(), 2);
         
        return std::make_unique<MdtPrepData>(calibInput.identify(), 
                                             std::move(driftRadius), 
                                             std::move(cov), 
                                             descriptor,
                                             calibInput.tdc(),
                                             calibInput.adc(), 
                                             calibOutput.status());
     }

◆ decode() [1/2]

StatusCode Muon::MdtRdoToPrepDataToolMT::decode	(	const EventContext &	ctx,
		const std::vector< IdentifierHash > &	idVect
	)		const

overridevirtual

Decode method - declared in Muon::IMuonRdoToPrepDataTool.

Construct the hashes from the existing RDOs

Definition at line 256 of file MdtRdoToPrepDataToolMT.cxx.

                                                                                              {
  
         ATH_MSG_DEBUG("decodeMdtRDO for " << idVect.size() << " offline collections called");
  
         // setup output container
         ConvCache mdtPrepDataContainer = setupMdtPrepDataContainer(ctx);
         if (!mdtPrepDataContainer.isValid) { 
             return StatusCode::FAILURE; 
         }
  
       
         if (!m_decodeData) {
             ATH_MSG_DEBUG("Stored empty container. Decoding MDT RDO into MDT PrepRawData is switched off");
             return StatusCode::SUCCESS;
         }
         // seeded or unseeded decoding
         if (!idVect.empty()) {
             processPRDHashes(ctx, mdtPrepDataContainer, idVect);
         } else {
             std::vector<IdentifierHash> rdoHashes{};
             const MdtCsmContainer* rdoContainer = getRdoContainer(ctx);
             if (!rdoContainer || rdoContainer->empty()) return StatusCode::SUCCESS;
             rdoHashes.reserve(rdoContainer->size());
             for (const MdtCsm* csm : *rdoContainer) rdoHashes.push_back(csm->identifyHash());
  
             processPRDHashes(ctx, mdtPrepDataContainer, rdoHashes);
         }
         ATH_CHECK(mdtPrepDataContainer.finalize(msgStream()));
  
         return StatusCode::SUCCESS;
     }

◆ decode() [2/2]

StatusCode Muon::MdtRdoToPrepDataToolMT::decode	(	const EventContext &	ctx,
		const std::vector< uint32_t > &	robIds
	)		const

overridevirtual

Definition at line 204 of file MdtRdoToPrepDataToolMT.cxx.

                                                                                                               {
         SG::ReadCondHandle<MuonMDT_CablingMap> readHandle{m_readKey, ctx};
         const MuonMDT_CablingMap* readCdo{*readHandle};
         if (!readCdo) {
             ATH_MSG_ERROR("nullptr to the read conditions object");
             return StatusCode::FAILURE;
         }
         return decode(ctx, readCdo->getMultiLayerHashVec(robIds, msgStream()));
     }

◆ getMdtTwinPosition()

Muon::MdtDriftCircleStatus Muon::MdtRdoToPrepDataToolMT::getMdtTwinPosition	(	const MdtDigit &	prompt_digit,
		const MdtDigit &	twin_digit,
		double &	radius,
		double &	errRadius,
		double &	zTwin,
		double &	errZTwin,
		bool &	twinIsPrompt
	)		const

protected

method to get the twin tube 2nd coordinate

◆ getRdoContainer()

const MdtCsmContainer * Muon::MdtRdoToPrepDataToolMT::getRdoContainer ( const EventContext & ctx ) const

protected

Loads the input RDO container from StoreGate.

Definition at line 214 of file MdtRdoToPrepDataToolMT.cxx.

                                                                                                 {
         SG::ReadHandle rdoContainerHandle{m_rdoContainerKey, ctx};
         if (rdoContainerHandle.isValid()) {
             ATH_MSG_DEBUG("MdtgetRdoContainer success");
             return rdoContainerHandle.cptr();
         }
         ATH_MSG_WARNING("Retrieval of Mdt RDO container failed !");
         return nullptr;
     }

◆ handlePRDHash()

bool Muon::MdtRdoToPrepDataToolMT::handlePRDHash	(	const EventContext &	ctx,
		ConvCache &	mdtPrepDataContainer,
		IdentifierHash	rdoHash
	)		const

protected

Definition at line 235 of file MdtRdoToPrepDataToolMT.cxx.

                                                                              {
         const MdtCsmContainer* rdoContainer{getRdoContainer(ctx)};
  
         if (rdoContainer->empty()) {
             ATH_MSG_DEBUG("The container is empty");
             return true;
         }
         const MdtCsm* rdoColl = rdoContainer->indexFindPtr(rdoHash);
         if (!rdoColl) {
             ATH_MSG_DEBUG("The rdo container does not have the hash " << rdoHash);
             return true;
         }
         if (processCsm(ctx, mdtPrepDataContainer, rdoColl).isFailure()) {
             ATH_MSG_WARNING("processCsm failed for RDO id " << m_idHelperSvc->toString(rdoColl->identify()));
             return false;
         }
         return true;
     }

◆ initDeadChannels()

void Muon::MdtRdoToPrepDataToolMT::initDeadChannels ( const MuonGM::MdtReadoutElement * mydetEl )

protected

Definition at line 528 of file MdtRdoToPrepDataToolMT.cxx.

                                                                                     {
         PVConstLink cv = mydetEl->getMaterialGeom();  // it is "Multilayer"
         int nGrandchildren = cv->getNChildVols();
         if (nGrandchildren <= 0) return;
  
         std::vector<int> tubes;
         geoGetIds([&](int id) { tubes.push_back(id); }, &*cv);
         std::sort(tubes.begin(), tubes.end());
  
         const Identifier detElId = mydetEl->identify();
         const int ml = mydetEl->getMultilayer();
         std::vector<int>::iterator it = tubes.begin();
         for (int layer = 1; layer <= mydetEl->getNLayers(); layer++) {
             for (int tube = 1; tube <= mydetEl->getNtubesperlayer(); tube++) {
                 int want_id = layer * maxNTubesPerLayer + tube;
                 if (it != tubes.end() && *it == want_id) {
                     ++it;
                 } else {
                     it = std::lower_bound(tubes.begin(), tubes.end(), want_id);
                     if (it != tubes.end() && *it == want_id) {
                         ++it;
                     } else {
                         Identifier deadTubeId = m_idHelperSvc->mdtIdHelper().channelID(detElId, ml, layer, tube);
                         m_DeadChannels.insert(deadTubeId);
                         ATH_MSG_VERBOSE("adding dead tube "<<m_idHelperSvc->toString(deadTubeId));
                     }
                 }
             }
         }
         
     }

◆ initialize()

StatusCode Muon::MdtRdoToPrepDataToolMT::initialize ( )

overridevirtual

standard Athena-Algorithm method

Definition at line 147 of file MdtRdoToPrepDataToolMT.cxx.

                                                   {
         ATH_CHECK(m_calibrationTool.retrieve());
         ATH_MSG_VERBOSE("MdtCalibrationTool retrieved with pointer = " << m_calibrationTool);
         ATH_CHECK(m_prdContainerCacheKey.initialize(!m_prdContainerCacheKey.key().empty()));
         ATH_CHECK(m_idHelperSvc.retrieve());
         // Retrieve the RDO decoder
         ATH_CHECK(m_mdtDecoder.retrieve());
  
         ATH_CHECK(m_twinTubeKey.initialize(m_useTwin));
       
         m_BMGid = m_idHelperSvc->mdtIdHelper().stationNameIndex("BMG");
         m_BMGpresent = m_BMGid != -1;
         if (m_useNewGeo) {
             ATH_CHECK(detStore()->retrieve(m_detMgrR4));
         }
         if (m_BMGpresent && !m_useNewGeo) {
             const MuonGM::MuonDetectorManager* muDetMgr = nullptr;
             ATH_CHECK(detStore()->retrieve(muDetMgr));
  
             ATH_MSG_INFO("Processing configuration for layouts with BMG chambers.");
  
             for (int phi = 6; phi < 8; phi++) {                 // phi sectors
                 for (int eta = 1; eta < 4; eta++) {             // eta sectors
                     for (int side = -1; side < 2; side += 2) {  // side
                         if (!muDetMgr->getMuonStation("BMG", side * eta, phi)) continue;
                         for (int roe = 1; roe <= (muDetMgr->getMuonStation("BMG", side * eta, phi))->nMuonReadoutElements();
                              roe++) {  // iterate on readout elemets
                             const MdtReadoutElement* mdtRE = dynamic_cast<const MdtReadoutElement*>(
                                 (muDetMgr->getMuonStation("BMG", side * eta, phi))->getMuonReadoutElement(roe));  // has to be an MDT
                             if (mdtRE) initDeadChannels(mdtRE);
                         }
                     }
                 }
             }
         } else if (m_useNewGeo) {
             std::vector<const MuonGMR4::MdtReadoutElement*> mdtRE = m_detMgrR4->getAllMdtReadoutElements();
             for (const MuonGMR4::MdtReadoutElement* re : mdtRE) {
                 if (re->stationName() != m_BMGid) {
                     continue;
                 }
                 for (const IdentifierHash& dead : re->getParameters().removedTubes) {
                     m_DeadChannels.insert(re->measurementId(dead));
                 }
             }
         }
  
         // check if initializing of DataHandle objects success
         ATH_CHECK(m_rdoContainerKey.initialize());
         ATH_CHECK(m_mdtPrepDataContainerKey.initialize());
         ATH_CHECK(m_readKey.initialize());
         ATH_CHECK(m_muDetMgrKey.initialize());
         ATH_CHECK(m_xAODKey.initialize(!m_xAODKey.empty()));
         ATH_CHECK(m_xAODTwinKey.initialize(!m_xAODTwinKey.empty()));
         ATH_CHECK(m_geoCtxKey.initialize(m_useNewGeo));
         return StatusCode::SUCCESS;
     }

◆ printPrepDataImpl()

void Muon::MdtRdoToPrepDataToolMT::printPrepDataImpl ( const Muon::MdtPrepDataContainer * mdtPrepDataContainer ) const

protected

◆ processCsm()

StatusCode Muon::MdtRdoToPrepDataToolMT::processCsm	(	const EventContext &	ctx,
		ConvCache &	mdtPrepDataContainer,
		const MdtCsm *	rdoColl
	)		const

protected

MDT hit context

Definition at line 329 of file MdtRdoToPrepDataToolMT.cxx.

                                                                                                                          {
         const MdtIdHelper& id_helper = m_idHelperSvc->mdtIdHelper();
         // first handle the case of twin tubes
         if (m_useTwin) {
             if (cache.twinTubeMap->isTwinTubeLayer(rdoColl->identify())) {
                 return processCsmTwin(ctx, cache, rdoColl);
             }
         }
  
         ATH_MSG_DEBUG(" ***************** Start of processCsm");
  
         const Identifier elementId = id_helper.parentID(rdoColl->identify());
  
         uint16_t subdetId = rdoColl->SubDetId();
         uint16_t mrodId = rdoColl->MrodId();
         uint16_t csmId = rdoColl->CsmId();
         ATH_MSG_VERBOSE("Identifier = " << m_idHelperSvc->toString(elementId) << " subdetId/ mrodId/ csmId = " << subdetId << " / "
                                         << mrodId << " / " << csmId);
  
         // for each Csm, loop over AmtHit, converter AmtHit to digit
         // retrieve/create digit collection, and insert digit into collection
         int mc = 0;
         for (const MdtAmtHit* amtHit : *rdoColl) {
             mc++;
  
             // FIXME: Still use the digit class.
             ATH_MSG_VERBOSE("Amt Hit n. " << mc << " tdcId = " << amtHit->tdcId());
             std::unique_ptr<MdtDigit> newDigit{m_mdtDecoder->getDigit(ctx, *amtHit, subdetId, mrodId, csmId)};
             if (!newDigit) {
                 ATH_MSG_WARNING("Found issue MDT RDO decoder for subdetId/mrodId/csmId "
                                 << subdetId << "/" << mrodId << "/" << csmId << " amtHit channelId/tdcId =" << amtHit->channelId() << "/"
                                 << amtHit->tdcId());
                 continue;
             }
             // Do something with it
             Identifier channelId = newDigit->identify();
             if (newDigit->isMasked() || m_DeadChannels.count(channelId)) {
                 continue;
             }
             // Retrieve the proper PRD container. Note that there are cases where one CSM is either split into 2 chambers (BEE / BIS78
             // legacy) or 2 CSMs are split into one chamber
             MdtPrepDataCollection* driftCircleColl = cache.createCollection(channelId);
             if (!driftCircleColl) {
                 ATH_MSG_DEBUG("Corresponding multi layer " << m_idHelperSvc->toString(channelId) << " is already decoded.");
                 continue;
             }
  
             // check if the module ID of this channel is different from the CSM one
             // If it's the first case, create the additional collection
  
             ATH_MSG_VERBOSE("got digit with id ext / hash " << m_idHelperSvc->toString(channelId) << " / "
                                                             << driftCircleColl->identifyHash());
  
             // Rescale ADC/TDC of chambers using HPTDC digitization chip
             // Must create a new digit from the old one, because MdtDigit has no methods to set ADC/TDC
             if (m_idHelperSvc->hasHPTDC(channelId)) {
                 newDigit->setAdc(newDigit->adc() / 4);
                 newDigit->setTdc(newDigit->tdc() / 4);
             }
             const MdtCalibInput calibIn = m_useNewGeo ? MdtCalibInput{*newDigit, *m_detMgrR4, *cache.gctx}: 
                                                         MdtCalibInput{*newDigit, *cache.legacyDetMgr};
             const MdtCalibOutput calibResult{m_calibrationTool->calibrate(ctx, calibIn, false)};
  
             std::unique_ptr<MdtPrepData> newPrepData = createPrepData(calibIn, calibResult, cache);
             if (newPrepData) {
                 newPrepData->setHashAndIndex(driftCircleColl->identifyHash(), driftCircleColl->size());
                 driftCircleColl->push_back(std::move(newPrepData));
             }
         }
         return StatusCode::SUCCESS;
     }

◆ processCsmTwin()

StatusCode Muon::MdtRdoToPrepDataToolMT::processCsmTwin	(	const EventContext &	ctx,
		ConvCache &	mdtPrepDataContainer,
		const MdtCsm *	rdoColll
	)		const

protected

MDT hit context

Create new PrepData

check for the twin tube id

Definition at line 401 of file MdtRdoToPrepDataToolMT.cxx.

                                                                                                                          {
         const MdtIdHelper& id_helper = m_idHelperSvc->mdtIdHelper();
         ATH_MSG_DEBUG(" ***************** Start of processCsmTwin");
         ATH_MSG_DEBUG(" Number of AmtHit in this Csm " << rdoColl->size());
         Identifier elementId = id_helper.parentID(rdoColl->identify());
  
         uint16_t subdetId = rdoColl->SubDetId();
         uint16_t mrodId = rdoColl->MrodId();
         uint16_t csmId = rdoColl->CsmId();
         ATH_MSG_VERBOSE("Identifier = " << m_idHelperSvc->toString(elementId) << " subdetId/ mrodId/ csmId = " << rdoColl->SubDetId()
                                         << " / " << rdoColl->MrodId() << " / " << rdoColl->CsmId());
  
         // for each Csm, loop over AmtHit, converter AmtHit to digit
         // retrieve/create digit collection, and insert digit into collection        
         std::map<Identifier, std::array<std::unique_ptr<MdtDigit>, 2>> mdtDigitColl{};
  
         for (const MdtAmtHit* amtHit : *rdoColl) {
             std::unique_ptr<MdtDigit> newDigit{m_mdtDecoder->getDigit(ctx, *amtHit, subdetId, mrodId, csmId)};
  
             if (!newDigit) {
                 ATH_MSG_WARNING("Error in MDT RDO decoder for subdetId/mrodId/csmId "
                                 << subdetId << "/" << mrodId << "/" << csmId << " amtHit channelId/tdcId =" << amtHit->channelId() << "/"
                                 << amtHit->tdcId());
                 continue;
             }
             std::array<std::unique_ptr<MdtDigit>, 2> & moveTo = mdtDigitColl[newDigit->identify()];
             if (!moveTo[0]) {
                 moveTo[0] = std::move(newDigit);
             } else if  (!moveTo[1] && !m_discardSecondaryHitTwin) {
                 moveTo[1] = std::move(newDigit);
             } else {
                 ATH_MSG_VERBOSE(" TWIN TUBES: found a tertiary hit in a twin tube in one RdoCollection for "
                              << m_idHelperSvc->toString(newDigit->identify()) << " with adc  = " << newDigit->adc()
                              << "  tdc = " << newDigit->tdc());
             }
         }  // end for-loop over rdoColl
  
         auto convertTwins = [this, &cache, &ctx](std::unique_ptr<MdtDigit> digit,
                                                  std::unique_ptr<MdtDigit> digit2) {
             if (!digit || digit->isMasked() || !cache.legacyDetMgr) {
                 return;
             }
  
             MdtPrepDataCollection* driftCircleColl = cache.createCollection(digit->identify());
             
             if (!digit2 || digit2->isMasked()) {
                 ATH_MSG_VERBOSE("Got single digit " << m_idHelperSvc->toString(digit->identify())<<", tdc: "
                              <<digit->tdc()<<", adc: "<<digit->adc() 
                              << ", hash: "<< driftCircleColl->identifyHash());
  
                 const MdtCalibInput mdtCalibIn = m_useNewGeo ? MdtCalibInput{*digit, *m_detMgrR4, *cache.gctx}: 
                                                                MdtCalibInput{*digit, *cache.legacyDetMgr};
  
                 const MdtCalibOutput mdtCalibOut{m_calibrationTool->calibrate(ctx, mdtCalibIn, false)};
                     
                 std::unique_ptr<MdtPrepData> newPrepData = createPrepData(mdtCalibIn, mdtCalibOut, cache);
                 if (!newPrepData) return;
                 
                 newPrepData->setHashAndIndex(driftCircleColl->identifyHash(), driftCircleColl->size());
                 driftCircleColl->push_back(std::move(newPrepData));                
                 return;
             } 
             ATH_MSG_VERBOSE("Twin digit calibration "<<m_idHelperSvc->toString(digit->identify())
                          <<", tdc: "<<digit->tdc()<<", adc: "<<digit->adc()<<" -- "
                          <<m_idHelperSvc->toString(digit2->identify())
                          <<", tdc: "<<digit2->tdc()<<", adc: "<<digit2->adc());
             MdtCalibInput mdtCalib1st = m_useNewGeo ? MdtCalibInput{*digit, *m_detMgrR4, *cache.gctx}
                                                     : MdtCalibInput{*digit, *cache.legacyDetMgr};
                 
             MdtCalibInput mdtCalib2nd = m_useNewGeo ? MdtCalibInput{*digit2, *m_detMgrR4, *cache.gctx}
                                                     : MdtCalibInput{*digit2, *cache.legacyDetMgr};
                 
             updateClosestApproachTwin(mdtCalib1st);
             updateClosestApproachTwin(mdtCalib2nd);
  
             const MdtCalibTwinOutput twinCalib = m_calibrationTool->calibrateTwinTubes(ctx, 
                                                                                        std::move(mdtCalib1st), 
                                                                                        std::move(mdtCalib2nd));
  
             Amg::Vector2D hitPos{twinCalib.primaryDriftR(), twinCalib.locZ()};
             Amg::MatrixX cov(2, 2);
             cov(0, 0) = twinCalib.uncertPrimaryR() * twinCalib.uncertPrimaryR();
             cov(1, 1) = twinCalib.sigmaZ() * twinCalib.sigmaZ();
             cov(0, 1) = cov(1, 0) = 0;
                 
             const MuonGM::MdtReadoutElement* descriptor = cache.legacyDetMgr->getMdtReadoutElement(digit->identify());
             auto twin_newPrepData = std::make_unique<MdtTwinPrepData>(twinCalib.primaryID(),
                                                                       std::move(hitPos),
                                                                       std::move(cov),
                                                                       descriptor,
                                                                       twinCalib.primaryTdc(),
                                                                       twinCalib.primaryAdc(),
                                                                       twinCalib.twinTdc(),
                                                                       twinCalib.twinAdc(),
                                                                       twinCalib.primaryStatus());
                         
             ATH_MSG_VERBOSE(" MADE A 2D TWINPREPDATA " << m_idHelperSvc->toString(twinCalib.primaryID()) << " & "
                                                       << m_idHelperSvc->toString(twinCalib.twinID()) << " "<<twinCalib);
        
             ATH_MSG_VERBOSE("global pos center tube  " << Amg::toString(twin_newPrepData->globalPosition(), 2) << std::endl
                         <<"local pos center tube w/ TWIN INFO "<<Amg::toString(twinCalib.locZ() * Amg::Vector3D::UnitZ(), 2)<<std::endl
                         <<"global pos w/o TWIN INFO  "<<Amg::toString(descriptor->tubePos(twinCalib.primaryID())));
  
             twin_newPrepData->setHashAndIndex(driftCircleColl->identifyHash(), driftCircleColl->size());
             driftCircleColl->push_back(std::move(twin_newPrepData));
         };
  
         // iterate over mdtDigitColl
         for (auto &[id,  digits] : mdtDigitColl) {
             // get the twin hits from mdtDigitColl
             const Identifier twinId = cache.twinTubeMap->twinId(id);
             if (id != twinId) {
                 std::array<std::unique_ptr<MdtDigit>, 2>& twinDigits = mdtDigitColl[twinId];
                 ATH_MSG_VERBOSE("Convert digits: "<<digits[0].get()<<" "<<twinDigits[0].get());
                 convertTwins(std::move(digits[0]), std::move(twinDigits[0]));
                 ATH_MSG_VERBOSE("Convert digits: "<<digits[1].get()<<" "<<twinDigits[1].get());
                 convertTwins(std::move(digits[1]), std::move(twinDigits[1]));
             } else {
                 convertTwins(std::move(digits[0]), nullptr);
                 convertTwins(std::move(digits[1]), nullptr);
             }
         }
         return StatusCode::SUCCESS;
     }

◆ processPRDHashes()

void Muon::MdtRdoToPrepDataToolMT::processPRDHashes	(	const EventContext &	ctx,
		ConvCache &	mdtPrepDataContainer,
		const std::vector< IdentifierHash > &	chamberHashInRobs
	)		const

protected

Definition at line 228 of file MdtRdoToPrepDataToolMT.cxx.

                                                                                                               {
         for (const IdentifierHash& hash : multiLayerHashInRobs) {
             if (!handlePRDHash(ctx, mdtPrepDataContainer, hash)) { ATH_MSG_DEBUG("Failed to process hash " << hash); }
         }  // ends loop over chamberhash
     }

◆ provideEmptyContainer()

StatusCode Muon::MdtRdoToPrepDataToolMT::provideEmptyContainer ( const EventContext & ctx ) const

overridevirtual

Definition at line 224 of file MdtRdoToPrepDataToolMT.cxx.

                                                                                          {
         return setupMdtPrepDataContainer(ctx).isValid ? StatusCode::SUCCESS : StatusCode::FAILURE;
     }

◆ setupMdtPrepDataContainer()

MdtRdoToPrepDataToolMT::ConvCache Muon::MdtRdoToPrepDataToolMT::setupMdtPrepDataContainer ( const EventContext & ctx ) const

protected

Creates the prep data container to be written.

Retrieve the Geometry context if activated

Retrieve the legacy detector mananger if activated

Definition at line 559 of file MdtRdoToPrepDataToolMT.cxx.

                                                                                                                    {
  
         ConvCache cache{m_idHelperSvc.get()};
  
         SG::WriteHandle<MdtPrepDataContainer> handle{m_mdtPrepDataContainerKey, ctx};
         // Caching of PRD container
         if (m_prdContainerCacheKey.key().empty()) {
             // without the cache we just record the container
             StatusCode status = handle.record(std::make_unique<MdtPrepDataContainer>(m_idHelperSvc->mdtIdHelper().module_hash_max()));
             if (status.isFailure() || !handle.isValid()) {
                 ATH_MSG_FATAL("Could not record container of MDT PrepData Container at " << m_mdtPrepDataContainerKey.key());
                 return cache;
             }
             ATH_MSG_VERBOSE("Created container " << m_mdtPrepDataContainerKey.key());
             cache.legacyPrd = handle.ptr();
         } else {
             // use the cache to get the container
             SG::UpdateHandle update{m_prdContainerCacheKey, ctx};
             if (!update.isValid()) {
                 ATH_MSG_FATAL("Invalid UpdateHandle " << m_prdContainerCacheKey.key());
                 return cache;
             }
             StatusCode status = handle.record(std::make_unique<MdtPrepDataContainer>(update.ptr()));
             if (status.isFailure() || !handle.isValid()) {
                 ATH_MSG_FATAL("Could not record container of MDT PrepData Container using cache " << m_prdContainerCacheKey.key() << " - "
                                                                                                   << m_mdtPrepDataContainerKey.key());
                 return cache;
             }
             ATH_MSG_VERBOSE("Created container using cache for " << m_prdContainerCacheKey.key());
             cache.legacyPrd = handle.ptr();
         }
         if (!m_xAODTwinKey.empty()) {
             SG::WriteHandle writeHandle{m_xAODTwinKey, ctx};
             if (!writeHandle.recordNonConst(std::make_unique<xAOD::MdtTwinDriftCircleContainer>(),
                                             std::make_unique<xAOD::MdtTwinDriftCircleAuxContainer>()).isSuccess() ||
                 !writeHandle.isValid()) {
                 ATH_MSG_FATAL("Failed to write xAOD::MdtPrepDataContainer "<<m_xAODTwinKey.fullKey());
                 return cache;
             }
             cache.xAODTwinPrd = writeHandle.ptr();
         }
         if (!m_xAODKey.empty()) {
             SG::WriteHandle writeHandle{m_xAODKey, ctx};
             if (!writeHandle.recordNonConst(std::make_unique<xAOD::MdtDriftCircleContainer>(),
                                             std::make_unique<xAOD::MdtDriftCircleAuxContainer>()).isSuccess() ||
                 !writeHandle.isValid()) {
                 ATH_MSG_FATAL("Failed to write xAOD::MdtPrepDataContainer "<<m_xAODKey.fullKey());
                 return cache;
             }
             cache.xAODPrd = writeHandle.ptr();
         }
         if (!m_geoCtxKey.empty()) {
             SG::ReadHandle readHandle{m_geoCtxKey, ctx};
             if (!readHandle.isPresent()) {
                 ATH_MSG_FATAL("Failed to retrieve the geometry context "<<m_geoCtxKey.fullKey());
                 return cache;
             }
             cache.gctx = readHandle.cptr();
         }
         if (!m_muDetMgrKey.empty()) {
             SG::ReadCondHandle detMgrHandle{m_muDetMgrKey, ctx};
             if (!detMgrHandle.isValid()) {
                 ATH_MSG_FATAL("Failed to retrieve the detector manager from the conditions store "<<m_muDetMgrKey.fullKey());
                 return cache;
             }
             cache.legacyDetMgr = detMgrHandle.cptr();
         }
         if (m_useTwin) {
             SG::ReadCondHandle twinTubeHandle{m_twinTubeKey, ctx};
             if (!twinTubeHandle.isValid()) {
                 ATH_MSG_FATAL("Failed to initialize twin tube map "<<m_twinTubeKey.fullKey());
                 return cache;
             }
             cache.twinTubeMap = twinTubeHandle.cptr();
         }
         cache.r4DetMgr = m_detMgrR4;
         // Pass the container from the handle
         cache.isValid = true;
         return cache;
     }

Member Data Documentation

◆ m_adcCut

Gaudi::Property<int> Muon::MdtRdoToPrepDataToolMT::m_adcCut

protected

Initial value:

{this, "AdcCut", 50,

"Minimal cut on the adc to convert it into a prepdata object"}

member variables for algorithm properties:

Definition at line 136 of file MdtRdoToPrepDataToolMT.h.

◆ m_BMGid

int Muon::MdtRdoToPrepDataToolMT::m_BMGid {-1}

protected

Definition at line 145 of file MdtRdoToPrepDataToolMT.h.

◆ m_BMGpresent

bool Muon::MdtRdoToPrepDataToolMT::m_BMGpresent {false}

protected

Definition at line 144 of file MdtRdoToPrepDataToolMT.h.

◆ m_calibratePrepData

Gaudi::Property<bool> Muon::MdtRdoToPrepDataToolMT::m_calibratePrepData {this, "CalibratePrepData", true}

protected

toggle on/off calibration of MdtPrepData

Definition at line 138 of file MdtRdoToPrepDataToolMT.h.

◆ m_calibrationTool

ToolHandle<IMdtCalibrationTool> Muon::MdtRdoToPrepDataToolMT::m_calibrationTool {this, "CalibrationTool", "MdtCalibrationTool"}

protected

MDT calibration service.

Definition at line 119 of file MdtRdoToPrepDataToolMT.h.

◆ m_DeadChannels

std::unordered_set<Identifier> Muon::MdtRdoToPrepDataToolMT::m_DeadChannels {}

protected

Definition at line 154 of file MdtRdoToPrepDataToolMT.h.

◆ m_decodeData

Gaudi::Property<bool> Muon::MdtRdoToPrepDataToolMT::m_decodeData {this, "DecodeData", true}

protected

toggle on/off the decoding of MDT RDO into MdtPrepData

Definition at line 139 of file MdtRdoToPrepDataToolMT.h.

◆ m_detMgrR4

const MuonGMR4::MuonDetectorManager* Muon::MdtRdoToPrepDataToolMT::m_detMgrR4 {nullptr}

protected

Definition at line 125 of file MdtRdoToPrepDataToolMT.h.

◆ m_discardSecondaryHitTwin

Gaudi::Property<bool> Muon::MdtRdoToPrepDataToolMT::m_discardSecondaryHitTwin {this, "DiscardSecondaryHitTwin", false}

protected

Definition at line 149 of file MdtRdoToPrepDataToolMT.h.

◆ m_geoCtxKey

SG::ReadHandleKey<ActsGeometryContext> Muon::MdtRdoToPrepDataToolMT::m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "Stored alignment"}

protected

Definition at line 126 of file MdtRdoToPrepDataToolMT.h.

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Muon::MdtRdoToPrepDataToolMT::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

protected

Definition at line 116 of file MdtRdoToPrepDataToolMT.h.

◆ m_mdtDecoder

ToolHandle<Muon::IMDT_RDO_Decoder> Muon::MdtRdoToPrepDataToolMT::m_mdtDecoder {this, "Decoder", "Muon::MdtRDO_Decoder/MdtRDO_Decoder"}

protected

Definition at line 142 of file MdtRdoToPrepDataToolMT.h.

◆ m_mdtPrepDataContainerKey

SG::WriteHandleKey<Muon::MdtPrepDataContainer> Muon::MdtRdoToPrepDataToolMT::m_mdtPrepDataContainerKey {this, "OutputCollection", "MDT_DriftCircles"}

protected

MdtPrepRawData containers.

Definition at line 130 of file MdtRdoToPrepDataToolMT.h.

◆ m_muDetMgrKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> Muon::MdtRdoToPrepDataToolMT::m_muDetMgrKey

protected

Initial value:

{this, "DetectorManagerKey", "MuonDetectorManager",

"Key of input MuonDetectorManager condition data"}

Definition at line 159 of file MdtRdoToPrepDataToolMT.h.

◆ m_prdContainerCacheKey

SG::UpdateHandleKey<MdtPrepDataCollection_Cache> Muon::MdtRdoToPrepDataToolMT::m_prdContainerCacheKey

protected

Initial value:

{this, "MdtPrdContainerCacheKey", "",

"Optional external cache for the MDT PRD container"}

This is the key for the cache for the MDT PRD containers, can be empty.

Definition at line 162 of file MdtRdoToPrepDataToolMT.h.

◆ m_rdoContainerKey

SG::ReadHandleKey<MdtCsmContainer> Muon::MdtRdoToPrepDataToolMT::m_rdoContainerKey {this, "RDOContainer", "MDTCSM"}

protected

Definition at line 132 of file MdtRdoToPrepDataToolMT.h.

◆ m_readKey

SG::ReadCondHandleKey<MuonMDT_CablingMap> Muon::MdtRdoToPrepDataToolMT::m_readKey {this, "ReadKey", "MuonMDT_CablingMap", "Key of MuonMDT_CablingMap"}

protected

Definition at line 157 of file MdtRdoToPrepDataToolMT.h.

◆ m_sortPrepData

bool Muon::MdtRdoToPrepDataToolMT::m_sortPrepData = false

protected

Toggle on/off the sorting of the MdtPrepData.

Definition at line 140 of file MdtRdoToPrepDataToolMT.h.

◆ m_twinTubeKey

SG::ReadCondHandleKey<TwinTubeMap> Muon::MdtRdoToPrepDataToolMT::m_twinTubeKey {this, "TwinTubeKey", "MdtTwinTubeMap"}

protected

Definition at line 152 of file MdtRdoToPrepDataToolMT.h.

◆ m_useNewGeo

Gaudi::Property<bool> Muon::MdtRdoToPrepDataToolMT::m_useNewGeo

protected

Initial value:

{this, "UseR4DetMgr", false,

"Switch between the legacy and the new geometry"}

Definition at line 122 of file MdtRdoToPrepDataToolMT.h.

◆ m_useTwin

Gaudi::Property<bool> Muon::MdtRdoToPrepDataToolMT::m_useTwin {this, "UseTwin", true}

protected

Definition at line 148 of file MdtRdoToPrepDataToolMT.h.

◆ m_xAODKey

SG::WriteHandleKey<xAOD::MdtDriftCircleContainer> Muon::MdtRdoToPrepDataToolMT::m_xAODKey {this, "xAODKey", "", "If empty, do not produce xAOD, otherwise this is the key of the output xAOD MDT PRD container"}

protected

Definition at line 166 of file MdtRdoToPrepDataToolMT.h.

◆ m_xAODTwinKey

SG::WriteHandleKey<xAOD::MdtTwinDriftCircleContainer> Muon::MdtRdoToPrepDataToolMT::m_xAODTwinKey {this, "xAODTwinKey", "", "If empty, do not produce xAOD, otherwise this is the key of the output xAOD MDT PRD container"}

protected

Definition at line 167 of file MdtRdoToPrepDataToolMT.h.

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

Classes

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ MdtRdoToPrepDataToolMT()

◆ ~MdtRdoToPrepDataToolMT()

Member Function Documentation

◆ createPrepData()

◆ decode() [1/2]

◆ decode() [2/2]

◆ getMdtTwinPosition()

◆ getRdoContainer()

◆ handlePRDHash()

◆ initDeadChannels()

◆ initialize()

◆ printPrepDataImpl()

◆ processCsm()

◆ processCsmTwin()

◆ processPRDHashes()

◆ provideEmptyContainer()

◆ setupMdtPrepDataContainer()

Member Data Documentation

◆ m_adcCut

◆ m_BMGid

◆ m_BMGpresent

◆ m_calibratePrepData

◆ m_calibrationTool

◆ m_DeadChannels

◆ m_decodeData

◆ m_detMgrR4

◆ m_discardSecondaryHitTwin

◆ m_geoCtxKey

◆ m_idHelperSvc

◆ m_mdtDecoder

◆ m_mdtPrepDataContainerKey

◆ m_muDetMgrKey

◆ m_prdContainerCacheKey

◆ m_rdoContainerKey

◆ m_readKey

◆ m_sortPrepData

◆ m_twinTubeKey

◆ m_useNewGeo

◆ m_useTwin

◆ m_xAODKey

◆ m_xAODTwinKey