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)
	Constructor to instantiate the cache.
	~DataCache ()
	Overwrite the destructor to ensure that the xAOD containers are made.
DataCache &	operator= (DataCache &&other)=default
	Default move operator.
	DataCache (DataCache &&other)=default
	Default move constructor.
void	translateAndSort (sTgcPrepDataCollection &coll)
	Sort the prepdata collection by the Identifier of the objects contained and then translate the prd objects into xAOD objects.
void	translate (const sTgcPrepDataCollection &coll)
	Translate the prd objects conained in the collection to xAOD objects.

Public Attributes
StripCont_t	strips {}
	Container to hold the translated xAOD strips.
WireCont_t	wires {}
	Container to hold the translated xAOD wires.
PadCont_t	pads {}
	Container to hold the translated xAOD pads.
SG::WriteHandle< sTgcPrepDataContainer >	prdWriteHandle {}
	Instantiated WriteHandle.
std::vector< std::unique_ptr< sTgcPrepDataCollection > >	collections {}
	Prep data collections that will be appended to the container in store gate.
const MuonGMR4::MuonDetectorManager *	detMgr {nullptr}
	Pointer to the R4 detector manager.
bool	isValid {false}
	Flag indicating whether the container is valid.

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 )

Constructor to instantiate the cache.

Parameters

hashMax	Number of sTGC chambers (summarizing ML 1 + ML2)
key	The writeHandleKey to fetch the container from StoreGate

Definition at line 24 of file sTgcRdoToPrepDataToolMT.cxx.

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

~DataCache()

Muon::sTgcRdoToPrepDataToolMT::DataCache::~DataCache

(

)

Overwrite the destructor to ensure that the xAOD containers are made.

Definition at line 110 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

Default move constructor.

Member Function Documentation

operator=()

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

default

Default move operator.

translate()

void Muon::sTgcRdoToPrepDataToolMT::DataCache::translate

(

const sTgcPrepDataCollection &

coll

)

Translate the prd objects conained in the collection to xAOD objects.

Parameters

coll	Reference to the collection to process

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 45 of file sTgcRdoToPrepDataToolMT.cxx.

                                                                                   {
    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));
    }
}

translateAndSort()

void Muon::sTgcRdoToPrepDataToolMT::DataCache::translateAndSort

(

sTgcPrepDataCollection &

coll

)

Sort the prepdata collection by the Identifier of the objects contained and then translate the prd objects into xAOD objects.

Parameters

coll	Reference to the collection to process

update the index otherwise the persitification is not happy...

Definition at line 31 of file sTgcRdoToPrepDataToolMT.cxx.

                                                                                    {
    if (!detMgr) {
        return;
    }
    std::sort(coll.begin(), coll.end(),[](const sTgcPrepData*a, const sTgcPrepData* b){
        return a->identify() < b->identify();
    });
    std::size_t idx{0};
    for (sTgcPrepData* prd : coll) {
        prd->setHashAndIndex(coll.identifyHash(), idx++);
    }
    translate(coll);
}

Member Data Documentation

collections

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

Prep data collections that will be appended to the container in store gate.

Definition at line 87 of file sTgcRdoToPrepDataToolMT.h.

{};

detMgr

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

Pointer to the R4 detector manager.

Definition at line 89 of file sTgcRdoToPrepDataToolMT.h.

{nullptr};

isValid

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

Flag indicating whether the container is valid.

Definition at line 91 of file sTgcRdoToPrepDataToolMT.h.

{false};

pads

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

Container to hold the translated xAOD pads.

Definition at line 76 of file sTgcRdoToPrepDataToolMT.h.

{};

prdWriteHandle

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

Instantiated WriteHandle.

Definition at line 85 of file sTgcRdoToPrepDataToolMT.h.

{};

strips

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

Container to hold the translated xAOD strips.

Definition at line 72 of file sTgcRdoToPrepDataToolMT.h.

{};

wires

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

Container to hold the translated xAOD wires.

Definition at line 74 of file sTgcRdoToPrepDataToolMT.h.

{};

---

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

• sTgcRdoToPrepDataToolMT.h
• sTgcRdoToPrepDataToolMT.cxx