RPCDigiValid Class Reference

#include <RPCDigiValid.h>

Inheritance diagram for RPCDigiValid:

Public Member Functions
	RPCDigiValid (const edm::ParameterSet &ps)
	~RPCDigiValid () override=default
Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) final
void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final
void	beginStream (edm::StreamID id) final
virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)
	DQMEDAnalyzer ()
void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
void	endRun (edm::Run const &run, edm::EventSetup const &setup) final
virtual bool	getCanSaveByLumi ()
Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
	EDProducer ()=default
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

Protected Member Functions
void	analyze (const edm::Event &e, const edm::EventSetup &c) override
void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const

Private Attributes
MonitorElement *	hBxDisc_4Min_
MonitorElement *	hBxDisc_4Plus_
MonitorElement *	hBxDist_
MonitorElement *	hDigiTime_
MonitorElement *	hDigiTimeAll_
MonitorElement *	hDigiTimeIRPC_
MonitorElement *	hDigiTimeNoIRPC_
MonitorElement *	hNDigiPerRoll_
MonitorElement *	hNSimHitPerRoll_
MonitorElement *	hRes_
std::map< int, MonitorElement * >	hResBarrelLayers_
std::map< int, MonitorElement * >	hResBarrelWheels_
std::map< int, MonitorElement * >	hResEndcapDisks_
std::map< int, MonitorElement * >	hResEndcapRings_
MonitorElement *	hRZ_
MonitorElement *	hStripProf_
MonitorElement *	hStripProf_Endcap_
MonitorElement *	hStripProf_IRPC_
MonitorElement *	hStripProf_RB12_
MonitorElement *	hStripProf_RB34_
MonitorElement *	hXY_Barrel_
std::map< int, MonitorElement * >	hXY_Endcap_
std::map< int, MonitorElement * >	hZPhi_
edm::EDGetTokenT< RPCDigiCollection >	rpcDigiToken_
edm::ESGetToken< RPCGeometry, MuonGeometryRecord >	rpcGeomToken_
edm::EDGetTokenT< edm::PSimHitContainer >	simHitToken_

Additional Inherited Members
Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore	DQMStore
typedef dqm::reco::MonitorElement	MonitorElement
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache
Static Public Member Functions inherited from DQMEDAnalyzer
static void	globalEndJob (DQMEDAnalyzerGlobalCache const *)
static void	globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)
static void	globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)
static std::unique_ptr< DQMEDAnalyzerGlobalCache >	initializeGlobalCache (edm::ParameterSet const &)
Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_
edm::EDPutTokenT< DQMToken >	runToken_
unsigned int	streamId_

Detailed Description

Definition at line 20 of file RPCDigiValid.h.

Constructor & Destructor Documentation

RPCDigiValid()

RPCDigiValid::RPCDigiValid

(

const edm::ParameterSet &

ps

)

Definition at line 18 of file RPCDigiValid.cc.

References deDxTools::esConsumes(), edm::ParameterSet::getUntrackedParameter(), and ProducerED_cfi::InputTag.

                                                 {
  //  Init the tokens for run data retrieval - stanislav
  //  ps.getUntackedParameter<InputTag> retrieves a InputTag from the
  //  configuration. The second param is default value module, instance and
  //  process labels may be passed in a single string if separated by colon ':'
  //  (@see the edm::InputTag constructor documentation)
  simHitToken_ = consumes<PSimHitContainer>(
      ps.getUntrackedParameter<edm::InputTag>("simHitTag", edm::InputTag("g4SimHits:MuonRPCHits")));
  rpcDigiToken_ = consumes<RPCDigiCollection>(
      ps.getUntrackedParameter<edm::InputTag>("rpcDigiTag", edm::InputTag("simMuonRPCDigis")));

  rpcGeomToken_ = esConsumes();
}

~RPCDigiValid()

RPCDigiValid::~RPCDigiValid ( )

overridedefault

Member Function Documentation

analyze()

void RPCDigiValid::analyze ( const edm::Event &  e, const edm::EventSetup &  c  )

overrideprotectedvirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 32 of file RPCDigiValid.cc.

References nano_mu_digi_cff::bx, hcalRecHitTable_cff::detId, PVValHelper::dx, options_cfi::eventSetup, RPCDetId::layer(), or, Pi, FastTimerService_cff::range, nano_mu_digi_cff::region, RPCDetId::region(), nano_mu_digi_cff::roll, relativeConstraints::station, RPCDetId::station(), nano_mu_digi_cff::strip, makeMuonMisalignmentScenario::wheel, and x.

                                                                           {
  // Get the RPC Geometry
  auto rpcGeom = eventSetup.getHandle(rpcGeomToken_);

  edm::Handle<PSimHitContainer> simHitHandle;
  edm::Handle<RPCDigiCollection> rpcDigisHandle;
  event.getByToken(simHitToken_, simHitHandle);
  event.getByToken(rpcDigiToken_, rpcDigisHandle);

  // loop over Simhit
  std::map<const RPCRoll *, std::vector<double>> detToSimHitXsMap;
  for (auto simIt = simHitHandle->begin(); simIt != simHitHandle->end(); ++simIt) {
    const RPCDetId rsid = simIt->detUnitId();
    const RPCRoll *roll = dynamic_cast<const RPCRoll *>(rpcGeom->roll(rsid));
    if (!roll)
      continue;

    if (detToSimHitXsMap.find(roll) == detToSimHitXsMap.end())
      detToSimHitXsMap[roll] = std::vector<double>();
    detToSimHitXsMap[roll].push_back(simIt->localPosition().x());

    const int region = rsid.region();
    const GlobalPoint gp = roll->toGlobal(simIt->localPosition());

    hRZ_->Fill(gp.z(), gp.perp());

    if (region == 0) {
      // Barrel
      hXY_Barrel_->Fill(gp.x(), gp.y());

      const int station = rsid.station();
      const int layer = rsid.layer();
      const int stla = (station <= 2) ? (2 * (station - 1) + layer) : (station + 2);

      auto match = hZPhi_.find(stla);
      if (match != hZPhi_.end()) {
        const double phiInDeg = 180. * gp.barePhi() / TMath::Pi();
        match->second->Fill(gp.z(), phiInDeg);
      }
    } else {
      // Endcap
      const int disk = region * rsid.station();
      auto match = hXY_Endcap_.find(disk);
      if (match != hXY_Endcap_.end())
        match->second->Fill(gp.x(), gp.y());
    }
  }
  for (auto detToSimHitXs : detToSimHitXsMap) {
    hNSimHitPerRoll_->Fill(detToSimHitXs.second.size());
  }

  // loop over Digis
  std::map<const RPCRoll *, std::vector<double>> detToDigiXsMap;
  for (auto detUnitIt = rpcDigisHandle->begin(); detUnitIt != rpcDigisHandle->end(); ++detUnitIt) {
    const RPCDetId rsid = (*detUnitIt).first;
    const RPCRoll *roll = dynamic_cast<const RPCRoll *>(rpcGeom->roll(rsid));
    if (!roll)
      continue;
    const int region = rsid.region();

    const RPCDigiCollection::Range &range = (*detUnitIt).second;

    for (auto digiIt = range.first; digiIt != range.second; ++digiIt) {
      // Strip profile
      const int strip = digiIt->strip();
      hStripProf_->Fill(strip);

      if (region == 0) {
        const int station = rsid.station();
        if (station == 1 or station == 2)
          hStripProf_RB12_->Fill(strip);
        else if (station == 3 or station == 4)
          hStripProf_RB34_->Fill(strip);
      } else {
        if (roll->isIRPC())
          hStripProf_IRPC_->Fill(strip);
        else
          hStripProf_Endcap_->Fill(strip);
      }

      // Bunch crossing
      const int bx = digiIt->bx();
      hBxDist_->Fill(bx);
      // bx for 4 endcaps
      if (rsid.station() == 4) {
        if (region == 1) {
          hBxDisc_4Plus_->Fill(bx);
        } else if (region == -1) {
          hBxDisc_4Min_->Fill(bx);
        }
      }

      // Fill timing information
      const double digiTime = digiIt->hasTime() ? digiIt->time() : digiIt->bx() * 25;
      hDigiTimeAll_->Fill(digiTime);
      if (digiIt->hasTime()) {
        hDigiTime_->Fill(digiTime);
        if (roll->isIRPC())
          hDigiTimeIRPC_->Fill(digiTime);
        else
          hDigiTimeNoIRPC_->Fill(digiTime);
      }

      // Keep digi position
      const double digiX = roll->centreOfStrip(digiIt->strip()).x();
      if (detToDigiXsMap.find(roll) == detToDigiXsMap.end())
        detToDigiXsMap[roll] = std::vector<double>();
      detToDigiXsMap[roll].push_back(digiX);
    }
  }
  for (auto detToDigiXs : detToDigiXsMap) {
    const auto digiXs = detToDigiXs.second;
    const int nDigi = digiXs.size();
    hNDigiPerRoll_->Fill(nDigi);

    // Fill residual plots, only for nDigi==1 and nSimHit==1
    const auto roll = detToDigiXs.first;
    const auto detId = roll->id();
    if (nDigi != 1)
      continue;
    if (detToSimHitXsMap.find(roll) == detToSimHitXsMap.end())
      continue;

    const auto simHitXs = detToSimHitXsMap[roll];
    const int nSimHit = simHitXs.size();
    if (nSimHit != 1)
      continue;

    const double dx = digiXs[0] - simHitXs[0];
    hRes_->Fill(dx);
    if (roll->isBarrel()) {
      const int wheel = detId.ring();  // ring() is wheel number for Barrel
      const int station = detId.station();
      const int layer = detId.layer();
      const int stla = (station <= 2) ? (2 * (station - 1) + layer) : (station + 2);

      auto matchLayer = hResBarrelLayers_.find(stla);
      if (matchLayer != hResBarrelLayers_.end())
        matchLayer->second->Fill(dx);

      auto matchWheel = hResBarrelWheels_.find(wheel);
      if (matchWheel != hResBarrelWheels_.end())
        matchWheel->second->Fill(dx);
    } else {
      const int disk = detId.region() * detId.station();
      auto matchDisk = hResEndcapDisks_.find(disk);
      if (matchDisk != hResEndcapDisks_.end())
        matchDisk->second->Fill(dx);

      auto matchRing = hResEndcapRings_.find(detId.ring());
      if (matchRing != hResEndcapRings_.end())
        matchRing->second->Fill(dx);
    }
  }
}

bookHistograms()

void RPCDigiValid::bookHistograms ( DQMStore::IBooker &  booker, edm::Run const &  run, edm::EventSetup const &  eSetup  )

overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 188 of file RPCDigiValid.cc.

References dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), dqm-mbProfile::format, CosmicsPD_Skims::maxZ, L1MuTriggerScales_cfi::nbinsPhi, relativeConstraints::ring, dqm::implementation::NavigatorBase::setCurrentFolder(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                         {
  booker.setCurrentFolder("RPCDigisV/RPCDigis");

  // Define binnings of 2D-histograms
  const double maxZ = 1100;
  const int nbinsZ = 220;  // bin width: 10cm
  const double maxXY = 800;
  const int nbinsXY = 160;  // bin width: 10cm
  const double minR = 100, maxR = 800;
  const int nbinsR = 70;    // bin width: 10cm
  const int nbinsPhi = 72;  // bin width: 5 degree
  const double maxBarrelZ = 700;
  const int nbinsBarrelZ = 140;  // bin width: 10cm

  // RZ plot
  hRZ_ = booker.book2D("RZ", "R-Z view;Z (cm);R (cm)", nbinsZ, -maxZ, maxZ, nbinsR, minR, maxR);

  // XY plots
  hXY_Barrel_ = booker.book2D("XY_Barrel", "X-Y view of Barrel", nbinsXY, -maxXY, maxXY, nbinsXY, -maxXY, maxXY);
  for (int disk = 1; disk <= 4; ++disk) {
    const std::string meNameP = fmt::format("XY_Endcap_p{:1d}", disk);
    const std::string meNameN = fmt::format("XY_Endcap_m{:1d}", disk);
    const std::string meTitleP = fmt::format("X-Y view of Endcap{:+1d};X (cm);Y (cm)", disk);
    const std::string meTitleN = fmt::format("X-Y view of Endcap{:+1d};X (cm);Y (cm)", -disk);
    hXY_Endcap_[disk] = booker.book2D(meNameP, meTitleP, nbinsXY, -maxXY, maxXY, nbinsXY, -maxXY, maxXY);
    hXY_Endcap_[-disk] = booker.book2D(meNameN, meTitleN, nbinsXY, -maxXY, maxXY, nbinsXY, -maxXY, maxXY);
  }

  // Z-phi plots
  for (int layer = 1; layer <= 6; ++layer) {
    const std::string meName = fmt::format("ZPhi_Layer{:1d}", layer);
    const std::string meTitle = fmt::format("Z-#phi view of Layer{:1d};Z (cm);#phi (degree)", layer);
    hZPhi_[layer] = booker.book2D(meName, meTitle, nbinsBarrelZ, -maxBarrelZ, maxBarrelZ, nbinsPhi, -180, 180);
  }

  // Strip profile
  hStripProf_ = booker.book1D("Strip_Profile", "Strip_Profile;Strip Number", 100, 0, 100);
  hStripProf_RB12_ = booker.book1D("Strip_Profile_RB12", "Strip Profile RB1 and RB2;Strip Number", 92, 0, 92);
  hStripProf_RB34_ = booker.book1D("Strip_Profile_RB34", "Strip Profile RB3 and RB4;Strip Number", 62, 0, 62);
  hStripProf_Endcap_ = booker.book1D("Strip_Profile_Endcap", "Strip Profile Endcap;Strip Number", 40, 0, 40);
  hStripProf_IRPC_ = booker.book1D("Strip_Profile_IRPC", "Strip Profile IRPC;Strip Number", 100, 0, 100);

  // Bunch crossing
  hBxDist_ = booker.book1D("Bunch_Crossing", "Bunch Crossing;Bunch crossing", 20, -10., 10.);
  hBxDisc_4Plus_ = booker.book1D("BxDisc_4Plus", "BxDisc_4Plus", 20, -10., 10.);
  hBxDisc_4Min_ = booker.book1D("BxDisc_4Min", "BxDisc_4Min", 20, -10., 10.);

  // Timing informations
  hDigiTimeAll_ =
      booker.book1D("DigiTimeAll", "Digi time including present electronics;Digi time (ns)", 100, -12.5, 12.5);
  hDigiTime_ = booker.book1D("DigiTime", "Digi time only with timing information;Digi time (ns)", 100, -12.5, 12.5);
  hDigiTimeIRPC_ = booker.book1D("DigiTimeIRPC", "IRPC Digi time;Digi time (ns)", 100, -12.5, 12.5);
  hDigiTimeNoIRPC_ = booker.book1D("DigiTimeNoIRPC", "non-IRPC Digi time;Digi time (ns)", 100, -12.5, 12.5);

  // SimHit and Digi multiplicity per roll
  hNSimHitPerRoll_ = booker.book1D("NSimHitPerRoll", "SimHit multiplicity per Roll;Multiplicity", 10, 0, 10);
  hNDigiPerRoll_ = booker.book1D("NDigiPerRoll", "Digi multiplicity per Roll;Multiplicity", 10, 0, 10);

  // Residual of SimHit-Digi x-position
  hRes_ = booker.book1D("Digi_SimHit_Difference", "Digi-SimHit difference;dx (cm)", 100, -8, 8);

  for (int layer = 1; layer <= 6; ++layer) {
    const std::string meName = fmt::format("Residual_Barrel_Layer{:1d}", layer);
    const std::string meTitle = fmt::format("Residual of Barrel Layer{:1d};dx (cm)", layer);
    hResBarrelLayers_[layer] = booker.book1D(meName, meTitle, 100, -8, 8);
  }

  hResBarrelWheels_[-2] = booker.book1D("Residual_Barrel_Wheel_m2", "Residual of Barrel Wheel-2;dx (cm)", 100, -8, 8);
  hResBarrelWheels_[-1] = booker.book1D("Residual_Barrel_Wheel_m1", "Residual of Barrel Wheel-1;dx (cm)", 100, -8, 8);
  hResBarrelWheels_[+0] = booker.book1D("Residual_Barrel_Wheel_00", "Residual of Barrel Wheel 0;dx (cm)", 100, -8, 8);
  hResBarrelWheels_[+1] = booker.book1D("Residual_Barrel_Wheel_p1", "Residual of Barrel Wheel+1;dx (cm)", 100, -8, 8);
  hResBarrelWheels_[+2] = booker.book1D("Residual_Barrel_Wheel_p2", "Residual of Barrel Wheel+2;dx (cm)", 100, -8, 8);

  for (int disk = 1; disk <= 4; ++disk) {
    const std::string meNameP = fmt::format("Residual_Endcap_Disk_p{:1d}", disk);
    const std::string meNameN = fmt::format("Residual_Endcap_Disk_m{:1d}", disk);
    const std::string meTitleP = fmt::format("Residual of Endcap Disk{:+1d};dx (cm)", disk);
    const std::string meTitleN = fmt::format("Residual of Endcap Disk{:+1d};dx (cm)", -disk);
    hResEndcapDisks_[+disk] = booker.book1D(meNameP, meTitleP, 100, -8, 8);
    hResEndcapDisks_[-disk] = booker.book1D(meNameN, meTitleN, 100, -8, 8);
  }

  for (int ring = 1; ring <= 3; ++ring) {
    const std::string meName = fmt::format("Residual_Endcap_Ring{:1d}", ring);
    const std::string meTitle = fmt::format("Residual of Endcap Ring{:1d};dx (cm)", ring);
    hResEndcapRings_[ring] = booker.book1D(meName, meTitle, 100, -8, 8);
  }
}

Member Data Documentation

hBxDisc_4Min_

MonitorElement* RPCDigiValid::hBxDisc_4Min_

private

Definition at line 45 of file RPCDigiValid.h.

hBxDisc_4Plus_

MonitorElement* RPCDigiValid::hBxDisc_4Plus_

private

Definition at line 44 of file RPCDigiValid.h.

hBxDist_

MonitorElement* RPCDigiValid::hBxDist_

private

Definition at line 43 of file RPCDigiValid.h.

hDigiTime_

MonitorElement * RPCDigiValid::hDigiTime_

private

Definition at line 48 of file RPCDigiValid.h.

hDigiTimeAll_

MonitorElement* RPCDigiValid::hDigiTimeAll_

private

Definition at line 48 of file RPCDigiValid.h.

hDigiTimeIRPC_

MonitorElement * RPCDigiValid::hDigiTimeIRPC_

private

Definition at line 48 of file RPCDigiValid.h.

hDigiTimeNoIRPC_

MonitorElement * RPCDigiValid::hDigiTimeNoIRPC_

private

Definition at line 48 of file RPCDigiValid.h.

hNDigiPerRoll_

MonitorElement * RPCDigiValid::hNDigiPerRoll_

private

Definition at line 51 of file RPCDigiValid.h.

hNSimHitPerRoll_

MonitorElement* RPCDigiValid::hNSimHitPerRoll_

private

Definition at line 51 of file RPCDigiValid.h.

hRes_

MonitorElement* RPCDigiValid::hRes_

private

Definition at line 54 of file RPCDigiValid.h.

hResBarrelLayers_

std::map<int, MonitorElement *> RPCDigiValid::hResBarrelLayers_

private

Definition at line 55 of file RPCDigiValid.h.

hResBarrelWheels_

std::map<int, MonitorElement *> RPCDigiValid::hResBarrelWheels_

private

Definition at line 56 of file RPCDigiValid.h.

hResEndcapDisks_

std::map<int, MonitorElement *> RPCDigiValid::hResEndcapDisks_

private

Definition at line 57 of file RPCDigiValid.h.

hResEndcapRings_

std::map<int, MonitorElement *> RPCDigiValid::hResEndcapRings_

private

Definition at line 58 of file RPCDigiValid.h.

hRZ_

MonitorElement* RPCDigiValid::hRZ_

private

Definition at line 31 of file RPCDigiValid.h.

hStripProf_

MonitorElement* RPCDigiValid::hStripProf_

private

Definition at line 38 of file RPCDigiValid.h.

hStripProf_Endcap_

MonitorElement* RPCDigiValid::hStripProf_Endcap_

private

Definition at line 40 of file RPCDigiValid.h.

hStripProf_IRPC_

MonitorElement * RPCDigiValid::hStripProf_IRPC_

private

Definition at line 40 of file RPCDigiValid.h.

hStripProf_RB12_

MonitorElement* RPCDigiValid::hStripProf_RB12_

private

Definition at line 39 of file RPCDigiValid.h.

hStripProf_RB34_

MonitorElement * RPCDigiValid::hStripProf_RB34_

private

Definition at line 39 of file RPCDigiValid.h.

hXY_Barrel_

MonitorElement* RPCDigiValid::hXY_Barrel_

private

Definition at line 33 of file RPCDigiValid.h.

hXY_Endcap_

std::map<int, MonitorElement *> RPCDigiValid::hXY_Endcap_

private

Definition at line 34 of file RPCDigiValid.h.

hZPhi_

std::map<int, MonitorElement *> RPCDigiValid::hZPhi_

private

Definition at line 35 of file RPCDigiValid.h.

rpcDigiToken_

edm::EDGetTokenT<RPCDigiCollection> RPCDigiValid::rpcDigiToken_

private

Definition at line 62 of file RPCDigiValid.h.

rpcGeomToken_

edm::ESGetToken<RPCGeometry, MuonGeometryRecord> RPCDigiValid::rpcGeomToken_

private

Definition at line 64 of file RPCDigiValid.h.

simHitToken_

edm::EDGetTokenT<edm::PSimHitContainer> RPCDigiValid::simHitToken_

private

Definition at line 61 of file RPCDigiValid.h.