Muon::MmRdoToPrepDataToolMT Class Reference

#include <MmRdoToPrepDataToolMT.h>

Inheritance diagram for Muon::MmRdoToPrepDataToolMT:

Collaboration diagram for Muon::MmRdoToPrepDataToolMT:

Public Member Functions
virtual	~MmRdoToPrepDataToolMT ()=default
	default destructor
virtual StatusCode	initialize () override
	standard Athena-Algorithm method
virtual StatusCode	decode (const EventContext &ctx, const std::vector< IdentifierHash > &idVect) const override
	Decode method - declared in Muon::IMuonRdoToPrepDataTool.
virtual StatusCode	decode (const EventContext &ctx, const std::vector< uint32_t > &robIds) const override
virtual StatusCode	provideEmptyContainer (const EventContext &ctx) const override
StatusCode	processCollection (const EventContext &ctx, Muon::MMPrepDataContainer *mmPrepDataContainer, xAOD::MMClusterContainer *xAODContainer, const std::vector< IdentifierHash > &idsToDecode, const MM_RawDataCollection *rdoColl) const

Protected Member Functions
Muon::MMPrepDataContainer *	setupMM_PrepDataContainer (const EventContext &ctx) const
xAOD::MMClusterContainer *	setupxAODPrepDataContainer (SG::WriteHandle< xAOD::MMClusterContainer > &outputContainer) const
const MM_RawDataContainer *	getRdoContainer (const EventContext &ctx) const
void	processRDOContainer (const EventContext &ctx, Muon::MMPrepDataContainer *mmPrepDataContainer, xAOD::MMClusterContainer *xAODContainer, const std::vector< IdentifierHash > &idsToDecode) const

Protected Attributes
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_muDetMgrKey
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc
SG::WriteHandleKey< Muon::MMPrepDataContainer >	m_writeKey
	MdtPrepRawData containers.
SG::ReadHandleKey< MM_RawDataContainer >	m_readKey
SG::UpdateHandleKey< MMPrepDataCollection_Cache >	m_updateKey
	This is the key for the cache for the MM PRD containers, can be empty.
Gaudi::Property< bool >	m_merge {this, "MergePrds", true}
ToolHandle< IMMClusterBuilderTool >	m_clusterBuilderTool
ToolHandle< INSWCalibTool >	m_calibTool {this, "NSWCalibTool", ""}
Gaudi::Property< float >	m_singleStripChargeCut
SG::WriteHandleKey< xAOD::MMClusterContainer >	m_xAODKey
Gaudi::Property< bool >	m_useNewGeo
const MuonGMR4::MuonDetectorManager *	m_detMgrR4 {nullptr}

Detailed Description

Definition at line 25 of file MmRdoToPrepDataToolMT.h.

Constructor & Destructor Documentation

~MmRdoToPrepDataToolMT()

virtual Muon::MmRdoToPrepDataToolMT::~MmRdoToPrepDataToolMT ( )

virtualdefault

default destructor

Member Function Documentation

decode() [1/2]

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

overridevirtual

Decode method - declared in Muon::IMuonRdoToPrepDataTool.

Definition at line 268 of file MmRdoToPrepDataToolMT.cxx.

                                                                                              {
 
  // is idVect a right thing to use here? to be reviewed maybe
  ATH_MSG_DEBUG("Size of the RDO container to be decoded: " << idVect.size());
 
  MMPrepDataContainer* mmPrepDataContainer = setupMM_PrepDataContainer(ctx);
 
  if (!mmPrepDataContainer) {
    return StatusCode::FAILURE;
  }
  
  SG::WriteHandle<xAOD::MMClusterContainer> outputContainer{};
  xAOD::MMClusterContainer* xAODContainer{nullptr};
  if (!m_xAODKey.empty()) {
    outputContainer = SG::WriteHandle{m_xAODKey, ctx};
    ATH_CHECK(outputContainer.record(std::make_unique<xAOD::MMClusterContainer>(),
                                             std::make_unique<xAOD::MMClusterAuxContainer>()));
    xAODContainer = outputContainer.ptr();
  }
 
  processRDOContainer(ctx, mmPrepDataContainer, xAODContainer, idVect);
 
  return StatusCode::SUCCESS;
}

decode() [2/2]

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

overridevirtual

Definition at line 294 of file MmRdoToPrepDataToolMT.cxx.

                                                                           {
  ATH_MSG_FATAL("ROB based decoding is not supported....");
  return StatusCode::FAILURE;
}

getRdoContainer()

const MM_RawDataContainer * Muon::MmRdoToPrepDataToolMT::getRdoContainer ( const EventContext & ctx ) const

protected

Definition at line 231 of file MmRdoToPrepDataToolMT.cxx.

                                                                      {
  auto rdoContainerHandle = SG::makeHandle(m_readKey, ctx);
  if (rdoContainerHandle.isValid()) {
    ATH_MSG_DEBUG("MM_getRdoContainer success");
    return rdoContainerHandle.cptr();
  }
  ATH_MSG_WARNING("Retrieval of MM_RawDataContainer failed !");
 
  return nullptr;
}

initialize()

StatusCode Muon::MmRdoToPrepDataToolMT::initialize ( )

overridevirtual

standard Athena-Algorithm method

Definition at line 26 of file MmRdoToPrepDataToolMT.cxx.

                                             {
  ATH_MSG_DEBUG(" in initialize()");
  ATH_CHECK(m_idHelperSvc.retrieve());
  // check if the initialization of the data container is success
  ATH_CHECK(m_writeKey.initialize());
  ATH_CHECK(m_readKey.initialize());
  ATH_CHECK(m_muDetMgrKey.initialize());
  ATH_CHECK(m_calibTool.retrieve());
  ATH_CHECK(m_updateKey.initialize(!m_updateKey.key().empty()));
  ATH_CHECK(m_xAODKey.initialize(!m_xAODKey.empty()));
  if (m_useNewGeo) {
      ATH_CHECK(detStore()->retrieve(m_detMgrR4));
  }
  return StatusCode::SUCCESS;
}

processCollection()

StatusCode Muon::MmRdoToPrepDataToolMT::processCollection	(	const EventContext &	ctx,
		Muon::MMPrepDataContainer *	mmPrepDataContainer,
		xAOD::MMClusterContainer *	xAODContainer,
		const std::vector< IdentifierHash > &	idsToDecode,
		const MM_RawDataCollection *	rdoColl ) const

reconstruct the clusters

Definition at line 42 of file MmRdoToPrepDataToolMT.cxx.

                                                                                               {
  ATH_MSG_DEBUG(" ***************** Start of process MM Collection");
  const MmIdHelper& id_helper = m_idHelperSvc->mmIdHelper();
  // protect for large splashes
  bool merge = m_merge || rdoColl->size() > 100;
 
  const IdentifierHash hash = rdoColl->identifierHash();
 
  // check if we actually want to decode this RDO collection
  if (!idsToDecode.empty() and std::find(idsToDecode.begin(), idsToDecode.end(),
                                         hash) == idsToDecode.end()) {
    ATH_MSG_DEBUG("Hash ID " << hash << " not in input list, ignore");
    return StatusCode::SUCCESS;
  } else
    ATH_MSG_DEBUG("Going to decode " << hash);
 
  // check if the collection already exists, otherwise add it
  if (mmPrepDataContainer->indexFindPtr(hash) != nullptr) {
 
    ATH_MSG_DEBUG("In processCollection: collection already contained in the MM PrepData container");
    return StatusCode::SUCCESS;
  }
 
  // Get write handle for this collection
  MMPrepDataContainer::IDC_WriteHandle lock = mmPrepDataContainer->getWriteHandle(hash);
  // Check if collection already exists (via the cache, i.e. in online trigger
  // mode)
  if (lock.OnlineAndPresentInAnotherView()) {
    ATH_MSG_DEBUG("In processCollection: collection already available in the MM PrepData container (via cache)");
    return StatusCode::SUCCESS;
  }
  auto prdColl = std::make_unique<MMPrepDataCollection>(hash);
 
  // set the offline identifier of the collection Id
  IdContext context = id_helper.module_context();
  Identifier moduleId{};
  if (id_helper.get_id(hash, moduleId, &context) != 0) {
    ATH_MSG_ERROR("Could not convert the hash Id: " << hash << " to identifier");
  } else {
    ATH_MSG_DEBUG(" dump moduleId " << moduleId);
    prdColl->setIdentifier(moduleId);
  }
 
  const MuonGM::MuonDetectorManager* MuonDetMgr{};
  ATH_CHECK(SG::get(MuonDetMgr, m_muDetMgrKey, ctx));
 
  std::vector<MMPrepData> MMprds;
  // convert the RDO collection to a PRD collection  
  for (const MM_RawData* rdo : *rdoColl) {
    ATH_MSG_DEBUG("Adding a new MM PrepRawData");
 
    const Identifier rdoId = rdo->identify();
    // ATH_MSG_ALWAYS(" dump rdo " << m_idHelperSvc->toString(rdoId) << " pdo " << rdo->charge()
    //               << " time " << rdo->time() << " relBCID " << rdo->relBcid());
 
    int channel = rdo->channel();
    std::vector<Identifier> rdoList;
    Identifier prdId = id_helper.channelID(rdoId, id_helper.multilayer(rdoId), id_helper.gasGap(rdoId), channel);
    ATH_MSG_DEBUG(" channel RDO " << channel << " channel from rdoID " << id_helper.channel(rdoId));
    rdoList.push_back(prdId);
 
    // get the local and global positions
    const MuonGM::MMReadoutElement* detEl = MuonDetMgr->getMMReadoutElement(prdId);
    Amg::Vector2D localPos{Amg::Vector2D::Zero()};
 
    bool getLocalPos = detEl->stripPosition(prdId, localPos);
    if (!getLocalPos) {
      if (msgLvl(MSG::DEBUG)) { // We should still keep this a warning and fix it properly but silence it for now (ATLASRECTS-7520)
        ATH_MSG_WARNING("Could not get the local strip position for "<< m_idHelperSvc->toString(prdId));
      }
      continue;
    }
 
    Amg::Vector3D globalPos{Amg::Vector3D::Zero()};
    bool getGlobalPos = detEl->stripGlobalPosition(prdId, globalPos);
    if (!getGlobalPos) {
      ATH_MSG_WARNING("Could not get the global strip position for MM");
      continue;
    }
    NSWCalib::CalibratedStrip calibStrip;
    ATH_CHECK(m_calibTool->calibrateStrip(ctx, rdo, calibStrip));
    if (calibStrip.charge < 0) {
      if (!hitNegativeCharge || msgLvl(MSG::DEBUG)) {
        ATH_MSG_DEBUG("One MM RDO or more, such as one with pdo = "<< rdo->charge()
                        << " counts, corresponds to a negative charge ("<< calibStrip.charge << "). Skipping these RDOs");
        hitNegativeCharge = true;
      }
      continue;
    }
 
    Trk::LocalDirection localDir;
    const Trk::PlaneSurface& psurf = detEl->surface(prdId);
    Amg::Vector2D lpos{Amg::Vector2D::Zero()};
    psurf.globalToLocal(globalPos, globalPos, lpos);
    psurf.globalToLocalDirection(globalPos, localDir);
 
    ATH_MSG_DEBUG(" Surface centre x " << Amg::toString(psurf.center()));
    ATH_MSG_DEBUG(" localPos x " <<Amg::toString(localPos)<< " localPos y " << Amg::toString(lpos));
 
    Amg::Vector3D gdir = psurf.transform().linear() * Amg::Vector3D::UnitY();
    ATH_MSG_DEBUG(" MM detector surface direction phi "<< gdir.phi() << " global radius hit " << globalPos.perp()
                  << " phi pos " << globalPos.phi() << " global z "<< globalPos.z());
 
    auto cov = Amg::MatrixX(2, 2);
    cov.setIdentity();
    (cov)(0, 0) = calibStrip.resTransDistDrift;
    (cov)(1, 1) = calibStrip.resLongDistDrift;
    localPos.x() += calibStrip.dx;
 
    if (!merge) {
      // storage will be handeled by Store Gate
     auto mpd = std::make_unique<MMPrepData>(prdId, hash, 
                                             std::move(localPos), std::move(rdoList), std::move(cov),
                                             detEl, 
                                             calibStrip.time, calibStrip.charge, calibStrip.distDrift);
      mpd->setAuthor(MMPrepData::Author::RDOTOPRDConverter);
 
      prdColl->push_back(std::move(mpd));
 
    } else {
      if (calibStrip.charge < m_singleStripChargeCut) {
        // ATH_MSG_ALWAYS("Strip with charge " << calibStrip.charge << " below the cut of " << m_singleStripChargeCut << ", skipping it");
        continue;
      }
      // ATH_MSG_ALWAYS("producing prd with charge " << calibStrip.charge << " time " << calibStrip.time);
      MMPrepData mpd(prdId, hash, std::move(localPos), std::move(rdoList),
                     std::move(cov), detEl, calibStrip.time, calibStrip.charge,
                     calibStrip.distDrift);
      // set the hash of the MMPrepData such that it contains the correct value
      // in case it gets used in SimpleMMClusterBuilderTool::getClusters
      mpd.setHashAndIndex(hash, 0);
      mpd.setAuthor(MMPrepData::Author::RDOTOPRDConverter);
      MMprds.push_back(std::move(mpd));
    }
  }
 
  if (merge) {
    std::vector<std::unique_ptr<MMPrepData>> clusters;

    ATH_CHECK(m_clusterBuilderTool->getClusters(ctx, std::move(MMprds), clusters));
 
    for (std::unique_ptr<MMPrepData>& prdN : clusters) {
      prdN->setHashAndIndex(prdColl->identifyHash(), prdColl->size());
      prdColl->push_back(std::move(prdN));
    }
  }  // merge
  
  if (xAODContainer) {
      // Lambda to fill xprd from prd
      std::vector<const MMPrepData*> sortMe{prdColl->begin(), prdColl->end()};
      std::ranges::sort(sortMe, IdentifierByDetElSorter{m_idHelperSvc.get()});
      for (const  MMPrepData* prd : sortMe) {
          xAOD::MMCluster* cluster{xAODContainer->push_back(std::make_unique<xAOD::MMCluster>())};
          cluster->setIdentifier(prd->identify().get_compact());
          cluster->setMeasurement(m_idHelperSvc->detElementHash(prd->identify()), 
                                  xAOD::MeasVector<1>{prd->localPosition().x()},
                                  xAOD::MeasMatrix<1>{prd->localCovariance()(0, 0)});
          cluster->setGasGap(id_helper.gasGap(prd->identify()));
          cluster->setChannelNumber(id_helper.channel(prd->identify()));
          cluster->setTime(prd->time());
          cluster->setCharge(prd->charge());
          cluster->setDriftDist(prd->driftDist());
          cluster->setAngle(prd->angle());
          cluster->setChiSqProb(prd->chisqProb());
          cluster->setAuthor(prd->author());
          cluster->setQuality(prd->quality());
          cluster->setStripNumbers(prd->stripNumbers());
          cluster->setStripTimes(prd->stripTimes());
          cluster->setStripCharges(prd->stripCharges());
          cluster->setStripDriftDist(prd->stripDriftDist());
          cluster->setStripDriftErrors(prd->stripDriftErrors());
          if (m_detMgrR4) {
            cluster->setReadoutElement(m_detMgrR4->getMmReadoutElement(prd->identify()));
          }
      }
  }
  // now write the collection
  ATH_CHECK(lock.addOrDelete(std::move(prdColl)));
  ATH_MSG_DEBUG("PRD hash " << hash << " has been moved to container");
 
  return StatusCode::SUCCESS;
}

processRDOContainer()

void Muon::MmRdoToPrepDataToolMT::processRDOContainer ( const EventContext & ctx, Muon::MMPrepDataContainer * mmPrepDataContainer, xAOD::MMClusterContainer * xAODContainer, const std::vector< IdentifierHash > & idsToDecode ) const

protected

Definition at line 242 of file MmRdoToPrepDataToolMT.cxx.

                                                                                                    {
  ATH_MSG_DEBUG("In processRDOContainer");
  const MM_RawDataContainer* rdoContainer = getRdoContainer(ctx);
  if (!rdoContainer) {
    return;
  }
 
  for (const MM_RawDataCollection* rdoColl : *rdoContainer) {
 
    if (rdoColl->empty()){
      continue;
    }
    ATH_MSG_DEBUG("New RDO collection with " << rdoColl->size() << "MM Hits");
 
    if (processCollection(ctx, mmPrepDataContainer, xAODContainer, idsToDecode, rdoColl).isFailure()) {
      ATH_MSG_DEBUG(
          "processCsm returns a bad StatusCode - keep going for new data "
          "collections in this event");
    }
  }
}

provideEmptyContainer()

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

overridevirtual

Definition at line 299 of file MmRdoToPrepDataToolMT.cxx.

                                                                                     {
  if (!m_xAODKey.empty()) {
    SG::WriteHandle writeHandle{m_xAODKey, ctx};
    ATH_CHECK(writeHandle.record(std::make_unique<xAOD::MMClusterContainer>(),
                                std::make_unique<xAOD::MMClusterAuxContainer>()));
  }
 
  return setupMM_PrepDataContainer(ctx) ? StatusCode::SUCCESS
                                        : StatusCode::FAILURE;
}

setupMM_PrepDataContainer()

MMPrepDataContainer * Muon::MmRdoToPrepDataToolMT::setupMM_PrepDataContainer ( const EventContext & ctx ) const

protected

Definition at line 311 of file MmRdoToPrepDataToolMT.cxx.

                                                                              {
 
  SG::WriteHandle handle{m_writeKey, ctx};
  if (m_updateKey.key().empty()) {
    // No external cache, just record the container
    StatusCode status =
        handle.record(std::make_unique<MMPrepDataContainer>(
            m_idHelperSvc->mmIdHelper().module_hash_max()));
 
    if (status.isFailure() || !handle.isValid()) {
      ATH_MSG_FATAL(
          "Could not record container of MicroMega PrepData Container at "
          << m_writeKey.key());
      return nullptr;
    }
  } else {
    // use the cache to get the container
    SG::UpdateHandle update(m_updateKey, ctx);
    if (!update.isValid()) {
      ATH_MSG_FATAL("Invalid UpdateHandle " << m_updateKey.key());
      return nullptr;
    }
    StatusCode status = handle.record(std::make_unique<MMPrepDataContainer>(update.ptr()));
    if (status.isFailure() || !handle.isValid()) {
      ATH_MSG_FATAL(
          "Could not record container of MM PrepData Container using cache "
          << m_updateKey.key() << " - "
          << m_writeKey.key());
      return nullptr;
    }
    ATH_MSG_DEBUG("Created container using cache for "
                  << m_updateKey.key());
  }
  return handle.ptr();
}

setupxAODPrepDataContainer()

xAOD::MMClusterContainer * Muon::MmRdoToPrepDataToolMT::setupxAODPrepDataContainer ( SG::WriteHandle< xAOD::MMClusterContainer > & outputContainer ) const

protected

Member Data Documentation

m_calibTool

ToolHandle<INSWCalibTool> Muon::MmRdoToPrepDataToolMT::m_calibTool {this, "NSWCalibTool", ""}

protected

Definition at line 83 of file MmRdoToPrepDataToolMT.h.

{this, "NSWCalibTool", ""};

m_clusterBuilderTool

ToolHandle<IMMClusterBuilderTool> Muon::MmRdoToPrepDataToolMT::m_clusterBuilderTool

protected

Initial value:

{
      this, "ClusterBuilderTool",
      "Muon::SimpleMMClusterBuilderTool/SimpleMMClusterBuilderTool"}

Definition at line 80 of file MmRdoToPrepDataToolMT.h.

                                                        {
      this, "ClusterBuilderTool",
      "Muon::SimpleMMClusterBuilderTool/SimpleMMClusterBuilderTool"};

m_detMgrR4

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

protected

Definition at line 98 of file MmRdoToPrepDataToolMT.h.

{nullptr};

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Muon::MmRdoToPrepDataToolMT::m_idHelperSvc

protected

Initial value:

{
      this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

Definition at line 65 of file MmRdoToPrepDataToolMT.h.

                                                   {
      this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

m_merge

Gaudi::Property<bool> Muon::MmRdoToPrepDataToolMT::m_merge {this, "MergePrds", true}

protected

Definition at line 78 of file MmRdoToPrepDataToolMT.h.

{this, "MergePrds", true};

m_muDetMgrKey

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

protected

Initial value:

{
      this, "DetectorManagerKey", "MuonDetectorManager",
      "Key of input MuonDetectorManager condition data"}

Definition at line 61 of file MmRdoToPrepDataToolMT.h.

                                                              {
      this, "DetectorManagerKey", "MuonDetectorManager",
      "Key of input MuonDetectorManager condition data"};

m_readKey

SG::ReadHandleKey<MM_RawDataContainer> Muon::MmRdoToPrepDataToolMT::m_readKey

protected

Initial value:

{
      this, "InputCollection", "MMRDO"}

Definition at line 71 of file MmRdoToPrepDataToolMT.h.

                                                {
      this, "InputCollection", "MMRDO"};

m_singleStripChargeCut

Gaudi::Property<float> Muon::MmRdoToPrepDataToolMT::m_singleStripChargeCut

protected

Initial value:

{
      this, "singleStripChargeCut",
      FLT_MIN }

Definition at line 87 of file MmRdoToPrepDataToolMT.h.

                                             {
      this, "singleStripChargeCut",
      FLT_MIN /*6241 * 0.4*/};  // 0.4 fC from BB5 cosmics

m_updateKey

SG::UpdateHandleKey<MMPrepDataCollection_Cache> Muon::MmRdoToPrepDataToolMT::m_updateKey

protected

Initial value:

{
      this, "PrdCacheKey", "",
      "Optional external cache for the MM PRD container"}

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

Definition at line 75 of file MmRdoToPrepDataToolMT.h.

                                                           {
      this, "PrdCacheKey", "",
      "Optional external cache for the MM PRD container"};

m_useNewGeo

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

protected

Initial value:

{this, "UseR4DetMgr", false,
                                    "Switch between the legacy and the new geometry"}

Definition at line 95 of file MmRdoToPrepDataToolMT.h.

                                 {this, "UseR4DetMgr", false,
                                    "Switch between the legacy and the new geometry"};

m_writeKey

SG::WriteHandleKey<Muon::MMPrepDataContainer> Muon::MmRdoToPrepDataToolMT::m_writeKey

protected

Initial value:

{
      this, "OutputCollection", "MM_Measurements"}

MdtPrepRawData containers.

Definition at line 69 of file MmRdoToPrepDataToolMT.h.

                                                      {
      this, "OutputCollection", "MM_Measurements"};

m_xAODKey

SG::WriteHandleKey<xAOD::MMClusterContainer> Muon::MmRdoToPrepDataToolMT::m_xAODKey

protected

Initial value:

{
      this, "xAODKey", "",
      "If empty, do not produce xAOD, otherwise this is the key of the output "
      "xAOD MDT PRD container"}

Definition at line 90 of file MmRdoToPrepDataToolMT.h.

                                                    {
      this, "xAODKey", "",
      "If empty, do not produce xAOD, otherwise this is the key of the output "
      "xAOD MDT PRD container"};

---

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

• MmRdoToPrepDataToolMT.h
• MmRdoToPrepDataToolMT.cxx