Muon::sTgcRdoToPrepDataToolMT::DataCache Struct Reference

Data cache to hold the translated prd & xAOD containers. More...

#include <sTgcRdoToPrepDataToolMT.h>

Collaboration diagram for Muon::sTgcRdoToPrepDataToolMT::DataCache:

Public Types
using	StripCont_t
using	WireCont_t
using	PadCont_t

Public Member Functions
	DataCache (const std::size_t hashMax, const PrdKey_t &key, const EventContext &ctx)
	~DataCache ()
DataCache &	operator= (DataCache &&other)=default
	DataCache (DataCache &&other)=default
void	translateAndSort (sTgcPrepDataCollection &coll)

Public Attributes
StripCont_t	strips {}
WireCont_t	wires {}
PadCont_t	pads {}
SG::WriteHandle< sTgcPrepDataContainer >	prdWriteHandle {}
std::vector< std::unique_ptr< sTgcPrepDataCollection > >	collections {}
const MuonGMR4::MuonDetectorManager *	detMgr {nullptr}
bool	isValid {false}

Detailed Description

Data cache to hold the translated prd & xAOD containers.

Definition at line 64 of file sTgcRdoToPrepDataToolMT.h.

Member Typedef Documentation

PadCont_t

using Muon::sTgcRdoToPrepDataToolMT::DataCache::PadCont_t

Initial value:

xAOD::FillContainer<xAOD::sTgcPadContainer,
                                             xAOD::sTgcPadAuxContainer>

Definition at line 69 of file sTgcRdoToPrepDataToolMT.h.

StripCont_t

using Muon::sTgcRdoToPrepDataToolMT::DataCache::StripCont_t

Initial value:

xAOD::FillContainer<xAOD::sTgcStripContainer,
                                               xAOD::sTgcStripAuxContainer>

Definition at line 65 of file sTgcRdoToPrepDataToolMT.h.

WireCont_t

using Muon::sTgcRdoToPrepDataToolMT::DataCache::WireCont_t

Initial value:

xAOD::FillContainer<xAOD::sTgcWireContainer,
                                              xAOD::sTgcWireAuxContainer>

Definition at line 67 of file sTgcRdoToPrepDataToolMT.h.

Constructor & Destructor Documentation

DataCache() [1/2]

Muon::sTgcRdoToPrepDataToolMT::DataCache::DataCache	(	const std::size_t	hashMax,
		const PrdKey_t &	key,
		const EventContext &	ctx )

Definition at line 24 of file sTgcRdoToPrepDataToolMT.cxx.

                                                                       :
        prdWriteHandle{key, ctx}{
    
    collections.resize(hashMax);
 
}

~DataCache()

Muon::sTgcRdoToPrepDataToolMT::DataCache::~DataCache

(

)

Definition at line 105 of file sTgcRdoToPrepDataToolMT.cxx.

                                             {
    if (!isValid) {
        return;
    }
    
    for (std::size_t hash = 0; hash < collections.size(); ++hash) {
        std::unique_ptr<sTgcPrepDataCollection>& coll = collections[hash];
        if (!coll) {
            continue;
        }
        sTgcPrepDataContainer::IDC_WriteHandle lock = prdWriteHandle->getWriteHandle( hash );
        if (lock.OnlineAndPresentInAnotherView()){
            continue;
        }
 
        translateAndSort(*coll);
 
        lock.addOrDelete(std::move(coll)).ignore();
    }
}

DataCache() [2/2]

Muon::sTgcRdoToPrepDataToolMT::DataCache::DataCache ( DataCache && other )

default

Member Function Documentation

operator=()

DataCache & Muon::sTgcRdoToPrepDataToolMT::DataCache::operator= ( DataCache && other )

default

translateAndSort()

void Muon::sTgcRdoToPrepDataToolMT::DataCache::translateAndSort

(

sTgcPrepDataCollection &

coll

)

Calculate the eta covariance from the geometry for now for

In the R4 layout both phi & eta measurements are expressed on the same surface. However, the rotation from eta -> phi is clockwise --> minus sign in prd creation

Definition at line 33 of file sTgcRdoToPrepDataToolMT.cxx.

                                                                                    {
    if (!detMgr) {
        return;
    }
    std::sort(coll.begin(), coll.end(),[](const sTgcPrepData*a, const sTgcPrepData* b){
        return a->identify() < b->identify();
    });
    const IMuonIdHelperSvc* idHelperSvc = detMgr->idHelperSvc();
    
    const sTgcIdHelper& id_helper = idHelperSvc->stgcIdHelper();
    for (const sTgcPrepData* prd : coll) {
        const Identifier prdId = prd->identify();
        const int gasGap = id_helper.gasGap(prdId);
        const int channel = id_helper.channel(prdId);
        const int chType = id_helper.channelType(prdId);
        xAOD::sTgcMeasurement* outHit{nullptr};
        if (chType == sTgcIdHelper::sTgcChannelTypes::Pad) {    
            if (!pads.hasHandle()) {
                continue;
            }          
            xAOD::MeasMatrix<2> lCov{xAOD::MeasMatrix<2>::Identity()};
            lCov(1,1) = prd->localCovariance()(0,0);
            const MuonGMR4::sTgcReadoutElement* readoutEle =  detMgr->getsTgcReadoutElement(prdId);
            lCov(0,0) = Acts::square(0.5* readoutEle->padHeight(readoutEle->measurementHash(prdId)));
 
            //skip for now measurements with zero covariance
            if (lCov.determinant() == 0) {
                continue;               
            }
            outHit = pads->push_back(std::make_unique<xAOD::sTgcPadHit>());
            outHit->setMeasurement<2>(idHelperSvc->detElementHash(prdId), 
                                      xAOD::toStorage(Eigen::Rotation2D{-M_PI_2}*prd->localPosition()),
                                      std::move(lCov));
        } else if (chType == sTgcIdHelper::sTgcChannelTypes::Wire) {
            if (!wires.hasHandle()){
                continue;
            }
            outHit = wires->push_back(std::make_unique<xAOD::sTgcWireHit>());
        } else if (chType == sTgcIdHelper::sTgcChannelTypes::Strip) {
            if (!strips.hasHandle()) {
                continue;
            }
            auto stripHit = strips->push_back(std::make_unique<xAOD::sTgcStripCluster>());
            stripHit->setStripCharges(prd->stripCharges());
            stripHit->setStripNumbers(prd->stripNumbers());
            stripHit->setStripTimes(prd->stripTimes());
            outHit = stripHit;
        }
        if (!outHit) {
            continue;
        }
        if (chType != sTgcIdHelper::sTgcChannelTypes::Pad){
            const double locPos = (chType == sTgcIdHelper::sTgcChannelTypes::Wire ? -1. : 1.) * prd->localPosition().x();
            xAOD::MeasVector<1> lPos = locPos * xAOD::MeasVector<1>::UnitX();
            xAOD::MeasMatrix<1> lCov{};
            lCov(0,0) = prd->localCovariance()(0,0);
            outHit->setMeasurement<1>(idHelperSvc->detElementHash(prdId),
                                      std::move(lPos),
                                      std::move(lCov));
 
        }
        outHit->setChannelNumber(channel);
        outHit->setGasGap(gasGap);
        outHit->setAuthor(prd->author());
        outHit->setTime(prd->time());
        outHit->setCharge(prd->charge());
        outHit->setReadoutElement(detMgr->getsTgcReadoutElement(prdId));
    }
}

Member Data Documentation

collections

std::vector<std::unique_ptr<sTgcPrepDataCollection> > Muon::sTgcRdoToPrepDataToolMT::DataCache::collections {}

Definition at line 81 of file sTgcRdoToPrepDataToolMT.h.

{};

detMgr

const MuonGMR4::MuonDetectorManager* Muon::sTgcRdoToPrepDataToolMT::DataCache::detMgr {nullptr}

Definition at line 83 of file sTgcRdoToPrepDataToolMT.h.

{nullptr};

isValid

bool Muon::sTgcRdoToPrepDataToolMT::DataCache::isValid {false}

Definition at line 85 of file sTgcRdoToPrepDataToolMT.h.

{false};

pads

PadCont_t Muon::sTgcRdoToPrepDataToolMT::DataCache::pads {}

Definition at line 73 of file sTgcRdoToPrepDataToolMT.h.

{};

prdWriteHandle

SG::WriteHandle<sTgcPrepDataContainer> Muon::sTgcRdoToPrepDataToolMT::DataCache::prdWriteHandle {}

Definition at line 79 of file sTgcRdoToPrepDataToolMT.h.

{};

strips

StripCont_t Muon::sTgcRdoToPrepDataToolMT::DataCache::strips {}

Definition at line 71 of file sTgcRdoToPrepDataToolMT.h.

{};

wires

WireCont_t Muon::sTgcRdoToPrepDataToolMT::DataCache::wires {}

Definition at line 72 of file sTgcRdoToPrepDataToolMT.h.

{};

---

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

• sTgcRdoToPrepDataToolMT.h
• sTgcRdoToPrepDataToolMT.cxx