VP1RawDataColl_MM_RDO.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 

//                                                            //
//  Implementation of class VP1RawDataColl_MM_RDO            //
//                                                            //
//  Author: Riccardo Maria BIANCHI <riccardo.maria.bianchi>
//  Initial version: December 2024                             //
//                                                            //
 
#include "VP1RawDataSystems/VP1RawDataCommonData.h"
#include "VP1RawDataSystems/VP1RawDataSysController.h"
#include "VP1RawDataSystems/VP1RawDataColl_MM_RDO.h"
#include "VP1RawDataSystems/VP1RawDataHandle_MM_RDO.h"
 
#include "VP1Utils/VP1JobConfigInfo.h"
#include "VP1Base/VP1MaterialButton.h"
#include "VP1Utils/VP1SGContentsHelper.h"
#include "VP1Utils/VP1SGAccessHelper.h"
 
#include "MuonReadoutGeometry/MuonDetectorManager.h"
 
#include "StoreGate/ReadCondHandle.h"
 
//____________________________________________________________________
QStringList VP1RawDataColl_MM_RDO::availableCollections(IVP1System*sys)
{
  return VP1SGContentsHelper(sys).getKeys<MmDigitContainer>();
}
 
//____________________________________________________________________
class VP1RawDataColl_MM_RDO::Imp {
public:
  VP1Interval mmAllowedCharge;
  VP1Interval mmAllowedTime;
 
};
 
 
//____________________________________________________________________
VP1RawDataColl_MM_RDO::VP1RawDataColl_MM_RDO(VP1RawDataCommonData*common,const QString& key)
  : VP1RawDataCollBase(common,key), m_d(new Imp)
{
  connect(common->controller(), SIGNAL(mmAllowedChargeChanged(const VP1Interval&)),
          this, SLOT(setMmAllowedCharge(const VP1Interval&)));
  setMmAllowedCharge(common->controller()->mmAllowedCharge());
  connect(common->controller(), SIGNAL(mmAllowedTimeChanged(const VP1Interval&)),
          this, SLOT(setMmAllowedTime(const VP1Interval&)));
  setMmAllowedTime(common->controller()->mmAllowedTime());
}
 
//____________________________________________________________________
VP1RawDataColl_MM_RDO::~VP1RawDataColl_MM_RDO()
{
  delete m_d;
}
 
//____________________________________________________________________
void VP1RawDataColl_MM_RDO::assignDefaultMaterial(SoMaterial*m) const
{
  VP1MaterialButton::setMaterialParametersFromRGB( m, 255, 136, 0, 0.1 );
}
 
//____________________________________________________________________
bool VP1RawDataColl_MM_RDO::load() {
  if (!VP1JobConfigInfo::hasMuonGeometry()) {
    message("Muon geometry not configured in job");
    return false;
  }
 
  // get the detMgr
  // TODO: we should probably simplify by moving to:
  //   const MuonGM::MuonDetectorManager * detmgr = VP1DetInfo::muonDetMgr();
  SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> detMgrKey{
      "MuonDetectorManager"};
  detMgrKey.initialize().ignore();
  SG::ReadCondHandle<MuonGM::MuonDetectorManager> detMgr{detMgrKey};
 
  SG::ReadHandleKey<MmDigitContainer> digitContainerKey{"MM_DIGITS"};
  digitContainerKey.initialize().ignore();
 
  const EventContext& ctx = Gaudi::Hive::currentContext();
 
  SG::ReadHandle<MmDigitContainer> container(digitContainerKey, ctx);
  if (!container.isValid()) {
    std::cout << "Could not find MmDigitContainer called " << container.name()
              << " in store " << container.store() << std::endl;
  }
 
  // Iterate on the collections
  for (const MmDigitCollection* coll : *container) {
    for (const MmDigit* digit : *coll) {
      const Identifier digitId{digit->identify()};
 
      // example from Johannes
      /*
      mdtReadoutElement = detMgr->getMdtReadoutElement(digitId);
      const Amg::Vector3D tubePos = mdtReadoutElement->tubePos(digitId);
      */
 
      if (digit)
        addHandle(new VP1RawDataHandle_MM_RDO(this, digit));
    }
  }
 
  return true;
}
 
//____________________________________________________________________
bool VP1RawDataColl_MM_RDO::cut(VP1RawDataHandleBase* handle)
{
  const auto* digit = static_cast<const VP1RawDataHandle_MM_RDO*>(handle);
  return m_d->mmAllowedCharge.contains(digit->amplitude()) &&
         m_d->mmAllowedTime.contains(digit->time());
}
 
void VP1RawDataColl_MM_RDO::setMmAllowedCharge(const VP1Interval& range)
{
  if (m_d->mmAllowedCharge == range)
    return;
  m_d->mmAllowedCharge = range;
  recheckCutStatusOfAllHandles();
}
 
void VP1RawDataColl_MM_RDO::setMmAllowedTime(const VP1Interval& range)
{
  if (m_d->mmAllowedTime == range)
    return;
  m_d->mmAllowedTime = range;
  recheckCutStatusOfAllHandles();
}