xAODContainerMaker Class Reference

#include <xAODContainerMaker.h>

Inheritance diagram for xAODContainerMaker:

Collaboration diagram for xAODContainerMaker:

Public Member Functions
StatusCode	initialize () override
StatusCode	makeStripClusterContainer (const int numClusters, const EFTrackingDataFormats::StripClusterAuxInput &scAux, const EFTrackingDataFormats::Metadata *meta, const EventContext &ctx) const
	Create xAOD::StripClusterContainer by creating xAOD::StripCluster objects one by one. More...
StatusCode	makePixelClusterContainer (const int numClusters, const EFTrackingDataFormats::PixelClusterAuxInput &pxAux, const EFTrackingDataFormats::Metadata *meta, const EventContext &ctx) const
	Create xAOD::PixelClusterContainer by creating xAOD::PixelCluster objects one by one. More...
StatusCode	makePixelSpacePointContainer (const int numPixelSpacePoints, const EFTrackingDataFormats::SpacePointAuxInput &psAux, const std::vector< std::vector< const xAOD::UncalibratedMeasurement * >> pixelsp_meas, const EventContext &ctx) const
	Create xAOD::SpacePointContainer by creating xAOD::SpacePoint for Pixel SpacePoint objects one by one. More...
StatusCode	makeStripSpacePointContainer (const int numStripSpacePoints, const EFTrackingDataFormats::SpacePointAuxInput &sspAux, const std::vector< std::vector< const xAOD::UncalibratedMeasurement * >> stripsp_meas, const EventContext &ctx) const
	Create xAOD::SpacePointContainer by creating xAOD::SpacePoint for Strip SpacePoint objects one by one. More...

Private Attributes
SG::WriteHandleKey< xAOD::PixelClusterContainer >	m_pixelClustersKey
	Key for the pixel cluster container. More...
SG::WriteHandleKey< xAOD::StripClusterContainer >	m_stripClustersKey
	Key for the strip cluster container. More...
SG::WriteHandleKey< xAOD::SpacePointContainer >	m_pixelSpacePointsKey
	Key for the Pixel SpacePoint container. More...
SG::WriteHandleKey< xAOD::SpacePointContainer >	m_stripSpacePointsKey
	Key for the Strip SpacePoint container. More...

Detailed Description

Definition at line 24 of file xAODContainerMaker.h.

Member Function Documentation

initialize()

StatusCode xAODContainerMaker::initialize ( )

override

Definition at line 20 of file xAODContainerMaker.cxx.

                                          {
  ATH_MSG_INFO("Initializing xAODContainerMaker tool");
 
  ATH_CHECK(m_pixelClustersKey.initialize());
  ATH_CHECK(m_stripClustersKey.initialize());
  ATH_CHECK(m_stripSpacePointsKey.initialize());
  ATH_CHECK(m_pixelSpacePointsKey.initialize());
 
  return StatusCode::SUCCESS;
}

makePixelClusterContainer()

StatusCode xAODContainerMaker::makePixelClusterContainer	(	const int	numClusters,
		const EFTrackingDataFormats::PixelClusterAuxInput &	pxAux,
		const EFTrackingDataFormats::Metadata *	meta,
		const EventContext &	ctx
	)		const

Create xAOD::PixelClusterContainer by creating xAOD::PixelCluster objects one by one.

Definition at line 83 of file xAODContainerMaker.cxx.

                                   {
  ATH_MSG_DEBUG("Making xAOD::PixelClusterContainer");
 
  SG::WriteHandle<xAOD::PixelClusterContainer> pixelClustersHandle{
      m_pixelClustersKey, ctx};
 
  ATH_CHECK(pixelClustersHandle.record(
      std::make_unique<xAOD::PixelClusterContainer>(),
      std::make_unique<xAOD::PixelClusterAuxContainer>()));
 
  ATH_CHECK(pixelClustersHandle.isValid());
  ATH_MSG_DEBUG("Container '" << m_pixelClustersKey << "' initialised");
 
  int rdoIndex_counter = 0;
  int totListIndex_counter = 0;
  int chargeListIndex_counter = 0;
 
  for (int i = 0; i < numClusters; i++) {
    // Puch back numClusters of PixelCluster
    auto pixelCl =
        pixelClustersHandle->push_back(std::make_unique<xAOD::PixelCluster>());
 
    Eigen::Matrix<float, 2, 1> localPosition(pxAux.localPosition.at(i * 2),
                                             pxAux.localPosition.at(i * 2 + 1));
    Eigen::Matrix<float, 2, 2> localCovariance;
    localCovariance.setZero();
    localCovariance(0, 0) = pxAux.localCovariance.at(i * 2);
    localCovariance(1, 1) = pxAux.localCovariance.at(i * 2 + 1);
    Eigen::Matrix<float, 3, 1> globalPosition(
        pxAux.globalPosition.at(i * 3), pxAux.globalPosition.at(i * 3 + 1),
        pxAux.globalPosition.at(i * 3 + 2));
 
    std::vector<Identifier> RDOs;
    RDOs.reserve(meta->pcRdoIndex[i]);
    // Cover RDO
    for (int j = 0; j < meta->pcRdoIndex[i]; ++j) {
      RDOs.push_back(Identifier(pxAux.rdoList.at(rdoIndex_counter + j)));
    }
 
    std::vector<int> vec_totList;
    vec_totList.reserve(meta->pcTotIndex[i]);
    for (int j = 0; j < meta->pcTotIndex[i]; ++j) {
      vec_totList.push_back(pxAux.totList.at(totListIndex_counter + j));
    }
 
    std::vector<float> vec_chargeList;
    vec_chargeList.reserve(meta->pcChargeIndex[i]);
    for (int k = 0; k < meta->pcChargeIndex[i]; ++k) {
      vec_chargeList.push_back(pxAux.totList.at(chargeListIndex_counter + k));
    }
 
    rdoIndex_counter += meta->pcRdoIndex[i];
    totListIndex_counter += meta->pcTotIndex[i];
    chargeListIndex_counter += meta->pcChargeIndex[i];
 
    pixelCl->setMeasurement<2>(pxAux.idHash.at(i), localPosition,
                               localCovariance);
    pixelCl->setIdentifier(pxAux.id.at(i));
    pixelCl->setRDOlist(RDOs);
    pixelCl->globalPosition() = globalPosition;
    pixelCl->setToTlist(vec_totList);
    pixelCl->setTotalToT(pxAux.totalToT.at(i));
    pixelCl->setChargelist(vec_chargeList);
    pixelCl->setTotalCharge(pxAux.totalCharge.at(i));
    pixelCl->setLVL1A(pxAux.lvl1a.at(i));
    pixelCl->setChannelsInPhiEta(pxAux.channelsInPhi.at(i),
                                 pxAux.channelsInEta.at(i));
    pixelCl->setWidthInEta(pxAux.widthInEta.at(i));
    pixelCl->setOmegas(pxAux.omegaX.at(i), pxAux.omegaY.at(i));
    pixelCl->setIsSplit(pxAux.isSplit.at(i));
    pixelCl->setSplitProbabilities(pxAux.splitProbability1.at(i),
                                   pxAux.splitProbability2.at(i));
  }
  return StatusCode::SUCCESS;
}

makePixelSpacePointContainer()

StatusCode xAODContainerMaker::makePixelSpacePointContainer	(	const int	numPixelSpacePoints,
		const EFTrackingDataFormats::SpacePointAuxInput &	psAux,
		const std::vector< std::vector< const xAOD::UncalibratedMeasurement * >>	pixelsp_meas,
		const EventContext &	ctx
	)		const

Create xAOD::SpacePointContainer by creating xAOD::SpacePoint for Pixel SpacePoint objects one by one.

Definition at line 163 of file xAODContainerMaker.cxx.

                                   {
  ATH_MSG_DEBUG("Making xAOD::SpacePointContainer");
 
  SG::WriteHandle<xAOD::SpacePointContainer> pixelSpacePointsHandle{
      m_pixelSpacePointsKey, ctx};
 
  ATH_CHECK(pixelSpacePointsHandle.record(
      std::make_unique<xAOD::SpacePointContainer>(),
      std::make_unique<xAOD::SpacePointAuxContainer>()));
 
  ATH_CHECK(pixelSpacePointsHandle.isValid());
  ATH_MSG_DEBUG("Container '" << m_pixelSpacePointsKey << "' initialised");
 
  for (int i = 0; i < numPixelSpacePoints; i++) {
    // Puch back numPixelSpacePoints of SpacePoint
    auto pxsp =
        pixelSpacePointsHandle->push_back(std::make_unique<xAOD::SpacePoint>());
    Eigen::Matrix<float, 3, 1> globalPosition(
        psAux.globalPosition.at(i * 3), psAux.globalPosition.at(i * 3 + 1),
        psAux.globalPosition.at(i * 3 + 2));
 
    std::vector<const xAOD::UncalibratedMeasurement *> pixel_meas(
        pixelsp_meas.at(i).size());
    std::copy(pixelsp_meas.at(i).begin(), pixelsp_meas.at(i).end(),
              pixel_meas.begin());
 
    pxsp->setSpacePoint(psAux.elementIdList.at(i), globalPosition,
                        psAux.varianceR.at(i), psAux.varianceZ.at(i),
                        pixel_meas);
  }
  return StatusCode::SUCCESS;
}

makeStripClusterContainer()

StatusCode xAODContainerMaker::makeStripClusterContainer	(	const int	numClusters,
		const EFTrackingDataFormats::StripClusterAuxInput &	scAux,
		const EFTrackingDataFormats::Metadata *	meta,
		const EventContext &	ctx
	)		const

Create xAOD::StripClusterContainer by creating xAOD::StripCluster objects one by one.

Definition at line 31 of file xAODContainerMaker.cxx.

                                   {
  ATH_MSG_DEBUG("Making xAOD::StripClusterContainer");
 
  SG::WriteHandle<xAOD::StripClusterContainer> stripClustersHandle{
      m_stripClustersKey, ctx};
 
  ATH_CHECK(stripClustersHandle.record(
      std::make_unique<xAOD::StripClusterContainer>(),
      std::make_unique<xAOD::StripClusterAuxContainer>()));
 
  int rdoIndex_counter = 0;
 
  for (int i = 0; i < numClusters; i++) {
    // Puch back numClusters of StripCluster
    auto stripCl =
        stripClustersHandle->push_back(std::make_unique<xAOD::StripCluster>());
 
    // Build Matrix
    Eigen::Matrix<float, 1, 1> localPosition;
    Eigen::Matrix<float, 1, 1> localCovariance;
 
    localPosition(0, 0) = scAux.localPosition.at(i);
    localCovariance(0, 0) = scAux.localCovariance.at(i);
 
    Eigen::Matrix<float, 3, 1> globalPosition(
        scAux.globalPosition.at(i * 3), scAux.globalPosition.at(i * 3 + 1),
        scAux.globalPosition.at(i * 3 + 2));
 
    std::vector<Identifier> RDOs;
    RDOs.reserve(meta->scRdoIndex[i]);
    // Cover RDO
    for (int j = 0; j < meta->scRdoIndex[i]; ++j) {
      RDOs.push_back(Identifier(scAux.rdoList.at(rdoIndex_counter + j)));
    }
 
    rdoIndex_counter += meta->scRdoIndex[i];
 
    stripCl->setMeasurement<1>(scAux.idHash.at(i), localPosition,
                               localCovariance);
    stripCl->setIdentifier(scAux.id.at(i));
    stripCl->setRDOlist(RDOs);
    stripCl->globalPosition() = globalPosition;
    stripCl->setChannelsInPhi(scAux.channelsInPhi.at(i));
  }
 
  return StatusCode::SUCCESS;
}

makeStripSpacePointContainer()

StatusCode xAODContainerMaker::makeStripSpacePointContainer	(	const int	numStripSpacePoints,
		const EFTrackingDataFormats::SpacePointAuxInput &	sspAux,
		const std::vector< std::vector< const xAOD::UncalibratedMeasurement * >>	stripsp_meas,
		const EventContext &	ctx
	)		const

Create xAOD::SpacePointContainer by creating xAOD::SpacePoint for Strip SpacePoint objects one by one.

Definition at line 201 of file xAODContainerMaker.cxx.

                                   {
  ATH_MSG_DEBUG("Making xAOD::SpacePointContainer");
 
  SG::WriteHandle<xAOD::SpacePointContainer> stripSpacePointsHandle{
      m_stripSpacePointsKey, ctx};
 
  ATH_CHECK(stripSpacePointsHandle.record(
      std::make_unique<xAOD::SpacePointContainer>(),
      std::make_unique<xAOD::SpacePointAuxContainer>()));
 
  ATH_CHECK(stripSpacePointsHandle.isValid());
  ATH_MSG_DEBUG("Container '" << m_stripSpacePointsKey << "' initialised");
 
  for (int i = 0; i < numStripSpacePoints; i++) {
    // Puch back numStripSpacePoints of SpacePoint
    auto ssp =
        stripSpacePointsHandle->push_back(std::make_unique<xAOD::SpacePoint>());
 
    Eigen::Matrix<float, 3, 1> globalPosition(
        sspAux.globalPosition.at(i * 3), sspAux.globalPosition.at(i * 3 + 1),
        sspAux.globalPosition.at(i * 3 + 2));
 
    std::vector<const xAOD::UncalibratedMeasurement *> strip_meas(
        stripsp_meas.at(i).size());
    std::copy(stripsp_meas.at(i).begin(), stripsp_meas.at(i).end(),
              strip_meas.begin());
 
    float topHalfStripLength = sspAux.topHalfStripLength.at(i);
    float bottomHalfStripLength = sspAux.bottomHalfStripLength.at(i);
    Eigen::Matrix<float, 3, 1> topStripDirection(
        sspAux.topStripDirection.at(i * 3),
        sspAux.topStripDirection.at(i * 3 + 1),
        sspAux.topStripDirection.at(i * 3 + 2));
    Eigen::Matrix<float, 3, 1> bottomStripDirection(
        sspAux.bottomStripDirection.at(i * 3),
        sspAux.bottomStripDirection.at(i * 3 + 1),
        sspAux.bottomStripDirection.at(i * 3 + 2));
    Eigen::Matrix<float, 3, 1> stripCenterDistance(
        sspAux.topStripCenter.at(i * 3), sspAux.topStripCenter.at(i * 3 + 1),
        sspAux.topStripCenter.at(i * 3 + 2));
    Eigen::Matrix<float, 3, 1> topStripCenter(
        sspAux.topStripCenter.at(i * 3), sspAux.topStripCenter.at(i * 3 + 1),
        sspAux.topStripCenter.at(i * 3 + 2));
    ssp->setSpacePoint(
        {sspAux.elementIdList.at(i), sspAux.elementIdList.at(i + 1)},
        globalPosition, sspAux.varianceR.at(i), sspAux.varianceZ.at(i),
        strip_meas, topHalfStripLength, bottomHalfStripLength,
        topStripDirection, bottomStripDirection, stripCenterDistance,
        topStripCenter);
  }
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_pixelClustersKey

SG::WriteHandleKey<xAOD::PixelClusterContainer> xAODContainerMaker::m_pixelClustersKey

private

Initial value:

{
      this, "OutputPixelName", "fpgaPixelClusters",
      "Output container name"}

Key for the pixel cluster container.

Definition at line 74 of file xAODContainerMaker.h.

m_pixelSpacePointsKey

SG::WriteHandleKey<xAOD::SpacePointContainer> xAODContainerMaker::m_pixelSpacePointsKey

private

Initial value:

{
      this, "OutputPixelSpacePointName", "fpgaPixelSpacePoints",
      "Output container name"}

Key for the Pixel SpacePoint container.

Definition at line 80 of file xAODContainerMaker.h.

m_stripClustersKey

SG::WriteHandleKey<xAOD::StripClusterContainer> xAODContainerMaker::m_stripClustersKey

private

Initial value:

{
      this, "OutputStripName", "fpgaStripClusters",
      "Output container name"}

Key for the strip cluster container.

Definition at line 77 of file xAODContainerMaker.h.

m_stripSpacePointsKey

SG::WriteHandleKey<xAOD::SpacePointContainer> xAODContainerMaker::m_stripSpacePointsKey

private

Initial value:

{
      this, "OutputStripSpacePointName", "fpgaStripSpacePoints",
      "Output container name"}

Key for the Strip SpacePoint container.

Definition at line 83 of file xAODContainerMaker.h.

---

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

• xAODContainerMaker.h
• xAODContainerMaker.cxx