GEMDQMBase Class Reference

#include <GEMDQMBase.h>

Inheritance diagram for GEMDQMBase:

Classes
class	BookingHelper
class	MEMapInfT
class	MEStationInfo

Public Types
enum	{   GEMDQM_RUNTYPE_ONLINE, GEMDQM_RUNTYPE_OFFLINE, GEMDQM_RUNTYPE_RELVAL, GEMDQM_RUNTYPE_ALLPLOTS,   GEMDQM_RUNTYPE_NONE = -1 }
typedef MEMapInfT< MEMap2Ids, ME2IdsKey >	MEMap2Inf
typedef MEMapInfT< MEMap3Ids, ME3IdsKey >	MEMap3Inf
typedef MEMapInfT< MEMap4Ids, ME4IdsKey >	MEMap4Inf
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

Public Member Functions
	GEMDQMBase (const edm::ParameterSet &cfg)
int	readGeometryPhiInfoChamber (const GEMStation *station, MEStationInfo &stationInfo)
int	readGeometryRadiusInfoChamber (const GEMStation *station, MEStationInfo &stationInfo)
	~GEMDQMBase () override
Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) final
virtual void	analyze (edm::Event const &, edm::EventSetup const &)
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	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &)=0
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

Public Attributes
std::string	log_category_
Int_t	nRunType_

Protected Member Functions
template<typename T >
bool	checkRefs (const std::vector< T *> &)
dqm::impl::MonitorElement *	CreateSummaryHist (DQMStore::IBooker &ibooker, TString strName)
int	GenerateMEPerChamber (DQMStore::IBooker &ibooker)
int	getDetOccXBin (const int, const int, const int)
int	getIEtaFromVFAT (const int station, const int vfat)
int	getIEtaFromVFATGE0 (const int vfat)
int	getIEtaFromVFATGE11 (const int vfat)
int	getIEtaFromVFATGE21 (const int vfat)
int	getMaxVFAT (const int)
std::string	getNameDirLayer (ME3IdsKey key3)
int	getNumEtaPartitions (const GEMStation *)
int	getVFATNumber (const int, const int, const int)
int	getVFATNumberByDigi (const int, const int, const int)
int	getVFATNumberGE11 (const int, const int, const int)
int	initGeometry (edm::EventSetup const &iSetup)
ME2IdsKey	key3Tokey2 (ME3IdsKey key)
ME3IdsKey	key4Tokey3 (ME4IdsKey key)
int	keyToChamber (ME4IdsKey key)
int	keyToIEta (ME3IdsKey key)
int	keyToIEta (ME4IdsKey key)
int	keyToLayer (ME3IdsKey key)
int	keyToLayer (ME4IdsKey key)
int	keyToRegion (ME2IdsKey key)
int	keyToRegion (ME3IdsKey key)
int	keyToRegion (ME4IdsKey key)
int	keyToStation (ME2IdsKey key)
int	keyToStation (ME3IdsKey key)
int	keyToStation (ME4IdsKey key)
int	loadChambers ()
virtual int	ProcessWithMEMap2 (BookingHelper &bh, ME2IdsKey key)
virtual int	ProcessWithMEMap2AbsReWithEta (BookingHelper &bh, ME3IdsKey key)
virtual int	ProcessWithMEMap2WithEta (BookingHelper &bh, ME3IdsKey key)
virtual int	ProcessWithMEMap3 (BookingHelper &bh, ME3IdsKey key)
virtual int	ProcessWithMEMap3WithChamber (BookingHelper &bh, ME4IdsKey key)
virtual int	ProcessWithMEMap4 (BookingHelper &bh, ME4IdsKey key)
Float_t	restrictAngle (const Float_t fTheta, const Float_t fStart)
int	SortingLayers (std::vector< ME3IdsKey > &listLayers)
Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const

Protected Attributes
const GEMGeometry *	GEMGeometry_
edm::ESGetToken< GEMGeometry, MuonGeometryRecord >	geomToken_
std::vector< GEMDetId >	listChamberId_
std::map< GEMDetId, std::vector< const GEMEtaPartition * > >	mapEtaPartition_
std::map< ME3IdsKey, MEStationInfo >	mapStationInfo_
std::map< ME3IdsKey, int >	mapStationToIdx_
std::map< ME3IdsKey, bool >	MEMap2AbsReWithEtaCheck_
std::map< ME2IdsKey, bool >	MEMap2Check_
std::map< ME3IdsKey, bool >	MEMap2WithEtaCheck_
std::map< ME3IdsKey, bool >	MEMap3Check_
std::map< ME4IdsKey, bool >	MEMap3WithChCheck_
std::map< ME4IdsKey, bool >	MEMap4Check_
int	nMaxNumCh_
Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_
edm::EDPutTokenT< DQMToken >	runToken_
unsigned int	streamId_

Additional Inherited Members
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 &)

Detailed Description

Definition at line 29 of file GEMDQMBase.h.

Member Typedef Documentation

MEMap2Inf

typedef MEMapInfT<MEMap2Ids, ME2IdsKey> GEMDQMBase::MEMap2Inf

Definition at line 458 of file GEMDQMBase.h.

MEMap3Inf

typedef MEMapInfT<MEMap3Ids, ME3IdsKey> GEMDQMBase::MEMap3Inf

Definition at line 459 of file GEMDQMBase.h.

MEMap4Inf

typedef MEMapInfT<MEMap4Ids, ME4IdsKey> GEMDQMBase::MEMap4Inf

Definition at line 460 of file GEMDQMBase.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
GEMDQM_RUNTYPE_ONLINE
GEMDQM_RUNTYPE_OFFLINE
GEMDQM_RUNTYPE_RELVAL
GEMDQM_RUNTYPE_ALLPLOTS
GEMDQM_RUNTYPE_NONE

Definition at line 514 of file GEMDQMBase.h.

       {
    GEMDQM_RUNTYPE_ONLINE,
    GEMDQM_RUNTYPE_OFFLINE,
    GEMDQM_RUNTYPE_RELVAL,
    GEMDQM_RUNTYPE_ALLPLOTS,
    GEMDQM_RUNTYPE_NONE = -1
  };

Constructor & Destructor Documentation

GEMDQMBase()

GEMDQMBase::GEMDQMBase ( const edm::ParameterSet &  cfg )

explicit

Definition at line 7 of file GEMDQMBase.cc.

References edm::BeginRun, looper::cfg, GEMDQM_RUNTYPE_ALLPLOTS, GEMDQM_RUNTYPE_OFFLINE, GEMDQM_RUNTYPE_ONLINE, GEMDQM_RUNTYPE_RELVAL, log_category_, nRunType_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                 : geomToken_(esConsumes<edm::Transition::BeginRun>()) {
  std::string strRunType = cfg.getUntrackedParameter<std::string>("runType");

  nRunType_ = GEMDQM_RUNTYPE_ONLINE;

  if (strRunType == "online") {
    nRunType_ = GEMDQM_RUNTYPE_ONLINE;
  } else if (strRunType == "offline") {
    nRunType_ = GEMDQM_RUNTYPE_OFFLINE;
  } else if (strRunType == "relval") {
    nRunType_ = GEMDQM_RUNTYPE_RELVAL;
  } else if (strRunType == "allplots") {
    nRunType_ = GEMDQM_RUNTYPE_ALLPLOTS;
  } else {
    edm::LogError(log_category_) << "+++ Error : GEM geometry is unavailable on event loop. +++\n";
  }

  log_category_ = cfg.getUntrackedParameter<std::string>("logCategory");
}

~GEMDQMBase()

GEMDQMBase::~GEMDQMBase ( )

inlineoverride

Definition at line 512 of file GEMDQMBase.h.

{};

Member Function Documentation

checkRefs()

template<typename T >

bool GEMDQMBase::checkRefs ( const std::vector< T *> &  refs )

inlineprotected

Definition at line 599 of file GEMDQMBase.h.

Referenced by getNumEtaPartitions().

                                                            {
  if (refs.empty())
    return false;
  if (refs.front() == nullptr)
    return false;
  return true;
}

CreateSummaryHist()

dqm::impl::MonitorElement * GEMDQMBase::CreateSummaryHist ( DQMStore::IBooker &  ibooker, TString  strName  )

protected

Definition at line 144 of file GEMDQMBase.cc.

References dqm::implementation::IBooker::book2D(), GEMUtils::getSuffixName(), mps_fire::i, crabWrapper::key, keyToLayer(), keyToRegion(), keyToStation(), label, mapStationInfo_, mapStationToIdx_, nMaxNumCh_, HLT_2022v15_cff::region, dqm::impl::MonitorElement::setXTitle(), and SortingLayers().

Referenced by GEMDAQStatusSource::bookHistograms().

                                                                                              {
  std::vector<ME3IdsKey> listLayers;
  for (auto const& [key, stationInfo] : mapStationInfo_)
    listLayers.push_back(key);
  SortingLayers(listLayers);
  for (Int_t i = 0; i < (Int_t)listLayers.size(); i++)
    mapStationToIdx_[listLayers[i]] = i + 1;

  auto h2Res =
      ibooker.book2D(strName, "", nMaxNumCh_, 0.5, nMaxNumCh_ + 0.5, listLayers.size(), 0.5, listLayers.size() + 0.5);
  h2Res->setXTitle("Chamber");
  h2Res->setYTitle("Layer");

  if (h2Res == nullptr)
    return nullptr;

  for (Int_t i = 1; i <= nMaxNumCh_; i++)
    h2Res->setBinLabel(i, Form("%i", i), 1);
  for (Int_t i = 1; i <= (Int_t)listLayers.size(); i++) {
    auto key = listLayers[i - 1];
    auto strInfo = GEMUtils::getSuffixName(key);  // NOTE: It starts with '_'
    auto region = keyToRegion(key);
    auto label =
        Form("GE%+i1-%cL%i;%s", region * keyToStation(key), (region > 0 ? 'P' : 'M'), keyToLayer(key), strInfo.Data());
    h2Res->setBinLabel(i, label, 2);
    Int_t nNumCh = mapStationInfo_[key].nNumChambers_;
    h2Res->setBinContent(0, i, nNumCh);
  }

  return h2Res;
}

GenerateMEPerChamber()

int GEMDQMBase::GenerateMEPerChamber ( DQMStore::IBooker &  ibooker )

protected

Definition at line 176 of file GEMDQMBase.cc.

References funct::abs(), GEMUtils::getSuffixName(), GEMUtils::getSuffixTitle(), l1tTowerCalibrationProducer_cfi::iEta, GEMDetId::ieta(), listChamberId_, mapEtaPartition_, MEMap2AbsReWithEtaCheck_, MEMap2Check_, MEMap2WithEtaCheck_, MEMap3Check_, MEMap3WithChCheck_, MEMap4Check_, ProcessWithMEMap2(), ProcessWithMEMap2AbsReWithEta(), ProcessWithMEMap2WithEta(), ProcessWithMEMap3(), ProcessWithMEMap3WithChamber(), and ProcessWithMEMap4().

Referenced by GEMRecHitSource::bookHistograms(), GEMDigiSource::bookHistograms(), and GEMDAQStatusSource::bookHistograms().

                                                             {
  MEMap2Check_.clear();
  MEMap2WithEtaCheck_.clear();
  MEMap2AbsReWithEtaCheck_.clear();
  MEMap3Check_.clear();
  MEMap3WithChCheck_.clear();
  MEMap4Check_.clear();
  for (auto gid : listChamberId_) {
    ME2IdsKey key2{gid.region(), gid.station()};
    ME3IdsKey key3{gid.region(), gid.station(), gid.layer()};
    ME4IdsKey key3WithChamber{gid.region(), gid.station(), gid.layer(), gid.chamber()};
    if (!MEMap2Check_[key2]) {
      auto strSuffixName = GEMUtils::getSuffixName(key2);
      auto strSuffixTitle = GEMUtils::getSuffixTitle(key2);
      BookingHelper bh2(ibooker, strSuffixName, strSuffixTitle);
      ProcessWithMEMap2(bh2, key2);
      MEMap2Check_[key2] = true;
    }
    if (!MEMap3Check_[key3]) {
      auto strSuffixName = GEMUtils::getSuffixName(key3);
      auto strSuffixTitle = GEMUtils::getSuffixTitle(key3);
      BookingHelper bh3(ibooker, strSuffixName, strSuffixTitle);
      ProcessWithMEMap3(bh3, key3);
      MEMap3Check_[key3] = true;
    }
    if (!MEMap3WithChCheck_[key3WithChamber]) {
      Int_t nCh = gid.chamber();
      Int_t nLa = gid.layer();
      char cLS = (nCh % 2 == 0 ? 'L' : 'S');  // FIXME: Is it general enough?
      auto strSuffixName = GEMUtils::getSuffixName(key2) + Form("-%02iL%i-%c", nCh, nLa, cLS);
      auto strSuffixTitle = GEMUtils::getSuffixTitle(key2) + Form("-%02iL%i-%c", nCh, nLa, cLS);
      BookingHelper bh3Ch(ibooker, strSuffixName, strSuffixTitle);
      ProcessWithMEMap3WithChamber(bh3Ch, key3WithChamber);
      MEMap3WithChCheck_[key3WithChamber] = true;
    }
    for (auto iEta : mapEtaPartition_[gid]) {
      GEMDetId eId = iEta->id();
      ME4IdsKey key4{gid.region(), gid.station(), gid.layer(), eId.ieta()};
      ME3IdsKey key2WithEta{gid.region(), gid.station(), eId.ieta()};
      ME3IdsKey key2AbsReWithEta{std::abs(gid.region()), gid.station(), eId.ieta()};
      if (!MEMap4Check_[key4]) {
        auto strSuffixName = GEMUtils::getSuffixName(key3) + Form("-E%02i", eId.ieta());
        auto strSuffixTitle = GEMUtils::getSuffixTitle(key3) + Form("-E%02i", eId.ieta());
        BookingHelper bh4(ibooker, strSuffixName, strSuffixTitle);
        ProcessWithMEMap4(bh4, key4);
        MEMap4Check_[key4] = true;
      }
      if (!MEMap2WithEtaCheck_[key2WithEta]) {
        auto strSuffixName = GEMUtils::getSuffixName(key2) + Form("-E%02i", eId.ieta());
        auto strSuffixTitle = GEMUtils::getSuffixTitle(key2) + Form("-E%02i", eId.ieta());
        BookingHelper bh3(ibooker, strSuffixName, strSuffixTitle);
        ProcessWithMEMap2WithEta(bh3, key2WithEta);
        MEMap2WithEtaCheck_[key2WithEta] = true;
      }
      if (!MEMap2AbsReWithEtaCheck_[key2AbsReWithEta]) {
        auto strSuffixName = Form("_GE%d1-E%02i", gid.station(), eId.ieta());
        auto strSuffixTitle = Form(" GE%d1-E%02i", gid.station(), eId.ieta());
        BookingHelper bh3(ibooker, strSuffixName, strSuffixTitle);
        ProcessWithMEMap2AbsReWithEta(bh3, key2AbsReWithEta);
        MEMap2AbsReWithEtaCheck_[key2AbsReWithEta] = true;
      }
    }
  }
  return 0;
}

getDetOccXBin()

int GEMDQMBase::getDetOccXBin ( const int  chamber, const int  layer, const int  n_chambers  )

inlineprotected

Definition at line 656 of file GEMDQMBase.h.

References relativeConstraints::chamber, and phase1PixelTopology::layer.

                                                                                             {
  return n_chambers * (chamber - 1) + layer;
}

getIEtaFromVFAT()

int GEMDQMBase::getIEtaFromVFAT ( const int  station, const int  vfat  )

inlineprotected

Definition at line 634 of file GEMDQMBase.h.

References getIEtaFromVFATGE0(), getIEtaFromVFATGE11(), getIEtaFromVFATGE21(), and relativeConstraints::station.

Referenced by GEMDQMBase::MEMapInfT< M, K >::SetLabelForVFATs().

                                                                        {
  if (station == 0)
    return getIEtaFromVFATGE0(vfat);
  if (station == 1)
    return getIEtaFromVFATGE11(vfat);
  if (station == 2)
    return getIEtaFromVFATGE21(vfat);
  return getIEtaFromVFATGE11(vfat);  // FIXME: What about GE21 and GE0?
}

getIEtaFromVFATGE0()

int GEMDQMBase::getIEtaFromVFATGE0 ( const int  vfat )

inlineprotected

Definition at line 644 of file GEMDQMBase.h.

References GEMeMap::maxiEtaIdGE0_.

Referenced by getIEtaFromVFAT().

                                                        {
  return GEMeMap::maxiEtaIdGE0_ - (vfat % GEMeMap::maxiEtaIdGE0_);
}

getIEtaFromVFATGE11()

int GEMDQMBase::getIEtaFromVFATGE11 ( const int  vfat )

inlineprotected

Definition at line 648 of file GEMDQMBase.h.

References GEMeMap::maxiEtaIdGE11_.

Referenced by getIEtaFromVFAT().

                                                         {
  return GEMeMap::maxiEtaIdGE11_ - (vfat % GEMeMap::maxiEtaIdGE11_);
}

getIEtaFromVFATGE21()

int GEMDQMBase::getIEtaFromVFATGE21 ( const int  vfat )

inlineprotected

Definition at line 652 of file GEMDQMBase.h.

References GEMeMap::maxiEtaIdGE21_.

Referenced by getIEtaFromVFAT().

                                                         {
  return GEMeMap::maxiEtaIdGE21_ - (vfat % GEMeMap::maxiEtaIdGE21_);
}

getMaxVFAT()

int GEMDQMBase::getMaxVFAT ( const int  station )

inlineprotected

Definition at line 608 of file GEMDQMBase.h.

References GEMeMap::maxVFatGE0_, GEMeMap::maxVFatGE11_, GEMeMap::maxVFatGE21_, and relativeConstraints::station.

Referenced by loadChambers().

                                                   {
  if (station == 0)
    return GEMeMap::maxVFatGE0_;
  if (station == 1)
    return GEMeMap::maxVFatGE11_;
  else if (station == 2)
    return GEMeMap::maxVFatGE21_;
  else
    return -1;
}

getNameDirLayer()

std::string GEMDQMBase::getNameDirLayer ( ME3IdsKey  key3 )

inlineprotected

Definition at line 666 of file GEMDQMBase.h.

References keyToLayer(), keyToRegion(), keyToStation(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by GEMRecHitSource::ProcessWithMEMap3WithChamber(), GEMDigiSource::ProcessWithMEMap3WithChamber(), and GEMDAQStatusSource::ProcessWithMEMap3WithChamber().

                                                           {
  auto nStation = keyToStation(key3);
  char cRegion = (keyToRegion(key3) > 0 ? 'P' : 'M');
  auto nLayer = keyToLayer(key3);
  return std::string(Form("GE%i1-%c-L%i", nStation, cRegion, nLayer));
}

getNumEtaPartitions()

int GEMDQMBase::getNumEtaPartitions ( const GEMStation *  station )

protected

Definition at line 40 of file GEMDQMBase.cc.

References chambers, checkRefs(), log_category_, and relativeConstraints::station.

Referenced by loadChambers().

                                                             {
  const auto&& superchambers = station->superChambers();
  if (not checkRefs(superchambers)) {
    edm::LogError(log_category_) << "failed to get a valid vector of GEMSuperChamber ptrs" << std::endl;
    return 0;
  }

  const auto& chambers = superchambers.front()->chambers();
  if (not checkRefs(chambers)) {
    edm::LogError(log_category_) << "failed to get a valid vector of GEMChamber ptrs" << std::endl;
    return 0;
  }

  return chambers.front()->nEtaPartitions();
}

getVFATNumber()

int GEMDQMBase::getVFATNumber ( const int  station, const int  ieta, const int  vfat_phi  )

inlineprotected

Definition at line 619 of file GEMDQMBase.h.

References getVFATNumberGE11(), LEDCalibrationChannels::ieta, and relativeConstraints::station.

Referenced by getVFATNumberByDigi().

                                                                                          {
  if (station == 1)
    return getVFATNumberGE11(station, ieta, vfat_phi);
  return getVFATNumberGE11(station, ieta, vfat_phi);  // FIXME: What about GE21 and GE0?
}

getVFATNumberByDigi()

int GEMDQMBase::getVFATNumberByDigi ( const int  station, const int  ieta, const int  digi  )

inlineprotected

Definition at line 629 of file GEMDQMBase.h.

References getVFATNumber(), LEDCalibrationChannels::ieta, GEMeMap::maxChan_, and relativeConstraints::station.

Referenced by GEMDigiSource::analyze().

                                                                                            {
  const int vfat_phi = digi / GEMeMap::maxChan_;
  return getVFATNumber(station, ieta, vfat_phi);
}

getVFATNumberGE11()

int GEMDQMBase::getVFATNumberGE11 ( const int  station, const int  ieta, const int  vfat_phi  )

inlineprotected

Definition at line 625 of file GEMDQMBase.h.

References LEDCalibrationChannels::ieta, and GEMeMap::maxiEtaIdGE11_.

Referenced by getVFATNumber().

                                                                                              {
  return vfat_phi * GEMeMap::maxiEtaIdGE11_ + (GEMeMap::maxiEtaIdGE11_ - ieta);
}

initGeometry()

int GEMDQMBase::initGeometry ( edm::EventSetup const &  iSetup )

protected

Definition at line 27 of file GEMDQMBase.cc.

References GEMGeometry_, geomToken_, edm::EventSetup::getHandle(), patZpeak::handle, and log_category_.

Referenced by GEMRecHitSource::bookHistograms(), GEMDigiSource::bookHistograms(), and GEMDAQStatusSource::bookHistograms().

                                                        {
  GEMGeometry_ = nullptr;
  if (auto handle = iSetup.getHandle(geomToken_)) {
    GEMGeometry_ = handle.product();
  } else {
    edm::LogError(log_category_) << "+++ Error : GEM geometry is unavailable on event loop. +++\n";
    return -1;
  }

  return 0;
}

key3Tokey2()

ME2IdsKey GEMDQMBase::key3Tokey2 ( ME3IdsKey  key )

inlineprotected

Definition at line 550 of file GEMDQMBase.h.

References crabWrapper::key, keyToRegion(), and keyToStation().

                                      {
    auto keyNew = ME2IdsKey{keyToRegion(key), keyToStation(key)};
    return keyNew;
  };

key4Tokey3()

ME3IdsKey GEMDQMBase::key4Tokey3 ( ME4IdsKey  key )

inlineprotected

Definition at line 555 of file GEMDQMBase.h.

References crabWrapper::key, keyToLayer(), keyToRegion(), and keyToStation().

Referenced by GEMRecHitSource::analyze(), GEMDAQStatusSource::analyze(), GEMDAQStatusSource::FillStatusSummaryPlot(), GEMRecHitSource::ProcessWithMEMap3WithChamber(), GEMDigiSource::ProcessWithMEMap3WithChamber(), and GEMDAQStatusSource::ProcessWithMEMap3WithChamber().

                                      {
    auto keyNew = ME3IdsKey{keyToRegion(key), keyToStation(key), keyToLayer(key)};
    return keyNew;
  };

keyToChamber()

int GEMDQMBase::keyToChamber ( ME4IdsKey  key )

inlineprotected

Definition at line 546 of file GEMDQMBase.h.

References crabWrapper::key.

Referenced by GEMDAQStatusSource::analyze(), and GEMDAQStatusSource::FillStatusSummaryPlot().

{ return std::get<3>(key); };

keyToIEta() [1/2]

int GEMDQMBase::keyToIEta ( ME3IdsKey  key )

inlineprotected

Definition at line 547 of file GEMDQMBase.h.

References crabWrapper::key.

Referenced by GEMRecHitSource::analyze().

{ return std::get<2>(key); };

keyToIEta() [2/2]

int GEMDQMBase::keyToIEta ( ME4IdsKey  key )

inlineprotected

Definition at line 548 of file GEMDQMBase.h.

References crabWrapper::key.

{ return std::get<3>(key); };

keyToLayer() [1/2]

int GEMDQMBase::keyToLayer ( ME3IdsKey  key )

inlineprotected

Definition at line 544 of file GEMDQMBase.h.

References crabWrapper::key.

Referenced by CreateSummaryHist(), getNameDirLayer(), and key4Tokey3().

{ return std::get<2>(key); };

keyToLayer() [2/2]

int GEMDQMBase::keyToLayer ( ME4IdsKey  key )

inlineprotected

Definition at line 545 of file GEMDQMBase.h.

References crabWrapper::key.

{ return std::get<2>(key); };

keyToRegion() [1/3]

int GEMDQMBase::keyToRegion ( ME2IdsKey  key )

inlineprotected

Definition at line 538 of file GEMDQMBase.h.

References crabWrapper::key.

Referenced by CreateSummaryHist(), getNameDirLayer(), key3Tokey2(), and key4Tokey3().

{ return std::get<0>(key); };

keyToRegion() [2/3]

int GEMDQMBase::keyToRegion ( ME3IdsKey  key )

inlineprotected

Definition at line 539 of file GEMDQMBase.h.

References crabWrapper::key.

{ return std::get<0>(key); };

keyToRegion() [3/3]

int GEMDQMBase::keyToRegion ( ME4IdsKey  key )

inlineprotected

Definition at line 540 of file GEMDQMBase.h.

References crabWrapper::key.

{ return std::get<0>(key); };

keyToStation() [1/3]

int GEMDQMBase::keyToStation ( ME2IdsKey  key )

inlineprotected

Definition at line 541 of file GEMDQMBase.h.

References crabWrapper::key.

Referenced by CreateSummaryHist(), getNameDirLayer(), key3Tokey2(), and key4Tokey3().

{ return std::get<1>(key); };

keyToStation() [2/3]

int GEMDQMBase::keyToStation ( ME3IdsKey  key )

inlineprotected

Definition at line 542 of file GEMDQMBase.h.

References crabWrapper::key.

{ return std::get<1>(key); };

keyToStation() [3/3]

int GEMDQMBase::keyToStation ( ME4IdsKey  key )

inlineprotected

Definition at line 543 of file GEMDQMBase.h.

References crabWrapper::key.

{ return std::get<1>(key); };

loadChambers()

int GEMDQMBase::loadChambers ( )

protected

Definition at line 56 of file GEMDQMBase.cc.

References chambers, GEMGeometry_, getMaxVFAT(), getNumEtaPartitions(), l1tTowerCalibrationProducer_cfi::iEta, listChamberId_, mapEtaPartition_, mapStationInfo_, SiStripPI::max, GEMeMap::maxChan_, nMaxNumCh_, readGeometryPhiInfoChamber(), readGeometryRadiusInfoChamber(), HLT_2022v15_cff::region, GEMGeometry::regions(), and relativeConstraints::station.

Referenced by GEMRecHitSource::bookHistograms(), GEMDigiSource::bookHistograms(), and GEMDAQStatusSource::bookHistograms().

                             {
  if (GEMGeometry_ == nullptr)
    return -1;
  listChamberId_.clear();
  mapEtaPartition_.clear();
  for (const GEMRegion* region : GEMGeometry_->regions()) {
    for (const GEMStation* station : region->stations()) {
      for (auto sch : station->superChambers()) {
        for (auto pchamber : sch->chambers()) {
          GEMDetId gid = pchamber->id();
          listChamberId_.push_back(pchamber->id());
          for (auto iEta : pchamber->etaPartitions()) {
            mapEtaPartition_[gid].push_back(iEta);
          }
        }
      }
    }
  }

  // Borrwed from DQM/GEM/src/GEMOfflineMonitor.cc
  nMaxNumCh_ = 0;
  for (const GEMRegion* region : GEMGeometry_->regions()) {
    const int region_number = region->region();

    for (const GEMStation* station : region->stations()) {
      const auto&& superchambers = station->superChambers();

      const int station_number = station->station();
      const int num_superchambers = (station_number == 1 ? 36 : 18);
      const int max_vfat = getMaxVFAT(station->station());  // the number of VFATs per GEMEtaPartition
      const int num_etas = getNumEtaPartitions(station);    // the number of eta partitions per GEMChamber
      const int num_vfat = num_etas * max_vfat;             // the number of VFATs per GEMChamber
      const int num_digi = GEMeMap::maxChan_;               // the number of digis (channels) per VFAT

      nMaxNumCh_ = std::max(nMaxNumCh_, num_superchambers);

      Int_t nMinIdxChamber = 1048576;
      Int_t nMaxIdxChamber = -1048576;
      for (auto sch : superchambers) {
        auto nIdxChamber = sch->chambers().front()->id().chamber();
        if (nMinIdxChamber > nIdxChamber)
          nMinIdxChamber = nIdxChamber;
        if (nMaxIdxChamber < nIdxChamber)
          nMaxIdxChamber = nIdxChamber;
      }

      const auto& chambers = superchambers.front()->chambers();

      for (auto pchamber : chambers) {
        int layer_number = pchamber->id().layer();
        ME3IdsKey key3(region_number, station_number, layer_number);
        mapStationInfo_[key3] = MEStationInfo(region_number,
                                              station_number,
                                              layer_number,
                                              num_superchambers,
                                              num_etas,
                                              num_vfat,
                                              num_digi,
                                              nMinIdxChamber,
                                              nMaxIdxChamber);
        readGeometryRadiusInfoChamber(station, mapStationInfo_[key3]);
        readGeometryPhiInfoChamber(station, mapStationInfo_[key3]);
      }
    }
  }

  return 0;
}

ProcessWithMEMap2()

virtual int GEMDQMBase::ProcessWithMEMap2 ( BookingHelper &  bh, ME2IdsKey  key  )

inlineprotectedvirtual

Reimplemented in GEMDigiSource.

Definition at line 531 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

{ return 0; };              // must be overrided

ProcessWithMEMap2AbsReWithEta()

virtual int GEMDQMBase::ProcessWithMEMap2AbsReWithEta ( BookingHelper &  bh, ME3IdsKey  key  )

inlineprotectedvirtual

Reimplemented in GEMRecHitSource.

Definition at line 533 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

{ return 0; };  // must be overrided

ProcessWithMEMap2WithEta()

virtual int GEMDQMBase::ProcessWithMEMap2WithEta ( BookingHelper &  bh, ME3IdsKey  key  )

inlineprotectedvirtual

Reimplemented in GEMDigiSource, and GEMRecHitSource.

Definition at line 532 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

{ return 0; };       // must be overrided

ProcessWithMEMap3()

virtual int GEMDQMBase::ProcessWithMEMap3 ( BookingHelper &  bh, ME3IdsKey  key  )

inlineprotectedvirtual

Reimplemented in GEMDAQStatusSource, GEMDigiSource, and GEMRecHitSource.

Definition at line 534 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

{ return 0; };              // must be overrided

ProcessWithMEMap3WithChamber()

virtual int GEMDQMBase::ProcessWithMEMap3WithChamber ( BookingHelper &  bh, ME4IdsKey  key  )

inlineprotectedvirtual

Reimplemented in GEMDAQStatusSource, GEMDigiSource, and GEMRecHitSource.

Definition at line 536 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

{ return 0; };   // must be overrided

ProcessWithMEMap4()

virtual int GEMDQMBase::ProcessWithMEMap4 ( BookingHelper &  bh, ME4IdsKey  key  )

inlineprotectedvirtual

Definition at line 535 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

{ return 0; };              // must be overrided

readGeometryPhiInfoChamber()

int GEMDQMBase::readGeometryPhiInfoChamber	(	const GEMStation *	station,
		MEStationInfo &	stationInfo
	)

Definition at line 303 of file GEMDQMBase.cc.

References funct::abs(), GEMDQMBase::MEStationInfo::fMinPhi_, l1tTowerCalibrationProducer_cfi::iEta, SiStripPI::max, SiStripPI::min, GEMDQMBase::MEStationInfo::nMaxVFAT_, GEMDQMBase::MEStationInfo::nNumDigi_, GEMDQMBase::MEStationInfo::nNumEtaPartitions_, AlCaHLTBitMon_ParallelJobs::p, PV3DBase< T, PVType, FrameType >::phi(), and relativeConstraints::station.

Referenced by loadChambers().

                                                                                                {
  auto listSuperChambers = station->superChambers();
  Int_t nNumStripEta = stationInfo.nNumDigi_ * (stationInfo.nMaxVFAT_ / stationInfo.nNumEtaPartitions_);

  std::vector<std::pair<Int_t, std::pair<std::pair<Float_t, Float_t>, Bool_t>>> listDivPhi;

  // Obtaining phi intervals of chambers
  for (auto superchamber : listSuperChambers) {
    auto iEta = superchamber->chambers().front()->etaPartitions().front();

    // What is the index of the first strip? Rather than to ask to someone, let's calculate it!
    Float_t fWidthStrip = std::abs(iEta->centreOfStrip((Int_t)1).x() - iEta->centreOfStrip((Int_t)0).x());
    LocalPoint lpRef(-fWidthStrip / 3.0, 0.0);
    Int_t nStripMid = (Int_t)iEta->strip(lpRef);
    Int_t nFirstStrip = 1 - ((nNumStripEta / 2) - nStripMid);
    Int_t nLastStrip = nFirstStrip + nNumStripEta - 1;

    auto& surface = iEta->surface();
    LocalPoint lpF = iEta->centreOfStrip((Float_t)(nFirstStrip - 0.5));  // To avoid the round error(?)
    LocalPoint lpL = iEta->centreOfStrip((Float_t)(nLastStrip + 0.5));   // To avoid the round error(?)
    GlobalPoint gpF = surface.toGlobal(lpF);
    GlobalPoint gpL = surface.toGlobal(lpL);

    Float_t fPhiF = gpF.phi();
    Float_t fPhiL = gpL.phi();
    if (fPhiF * fPhiL < 0 && std::abs(fPhiF) > 0.5 * 3.14159265359) {
      if (fPhiF < 0)
        fPhiF += 2 * 3.14159265359;
      if (fPhiL < 0)
        fPhiL += 2 * 3.14159265359;
    }
    Bool_t bFlipped = fPhiF > fPhiL;
    Float_t fPhiMin = std::min(fPhiF, fPhiL);
    Float_t fPhiMax = std::max(fPhiF, fPhiL);

    listDivPhi.emplace_back();
    listDivPhi.back().first = iEta->id().chamber();
    listDivPhi.back().second.first.first = fPhiMin;
    listDivPhi.back().second.first.second = fPhiMax;
    listDivPhi.back().second.second = bFlipped;
  }

  stationInfo.fMinPhi_ = 0.0;
  for (auto p : listDivPhi) {
    if (p.first == 1) {
      stationInfo.fMinPhi_ = p.second.first.first;
      break;
    }
  }

  // For a future usage
  //for ( auto p : listDivPhi ) {
  //  std::cout << "GEO_PHI: " << p.first << " "
  //    << p.second.first.first << " " << p.second.first.second << " " << p.second.second << std::endl;
  //}

  return 0;
}

readGeometryRadiusInfoChamber()

int GEMDQMBase::readGeometryRadiusInfoChamber	(	const GEMStation *	station,
		MEStationInfo &	stationInfo
	)

Definition at line 242 of file GEMDQMBase.cc.

References mps_fire::i, l1tTowerCalibrationProducer_cfi::iEta, createfilelist::int, GEMDQMBase::MEStationInfo::listRadiusEvenChamber_, GEMDQMBase::MEStationInfo::listRadiusOddChamber_, SiStripPI::max, SiStripPI::min, PV3DBase< T, PVType, FrameType >::perp(), jetsAK4_CHS_cff::sort, relativeConstraints::station, and GEMStripTopology::stripLength().

Referenced by loadChambers().

                                                                                                   {
  auto listSuperChambers = station->superChambers();

  Bool_t bDoneEven = false, bDoneOdd = false;

  // Obtaining radius intervals of even/odd chambers
  for (auto superchamber : listSuperChambers) {
    Int_t chamberNo = superchamber->id().chamber();
    if (chamberNo % 2 == 0 && bDoneEven)
      continue;
    if (chamberNo % 2 != 0 && bDoneOdd)
      continue;

    auto& etaPartitions = superchamber->chambers().front()->etaPartitions();

    // A little of additional procedures to list up the radius intervals
    // It would be independent to local direction of chambers and the order of eta partitions
    //   1. Obtain the radius of the middle top/bottom points of the trapezoid
    //   2. Sort these two values and determine which one is the lower/upper one
    //   3. Keep them all and then sort them
    //   4. The intermediate radii are set as the mean of the corresponding values of upper/lowers.
    std::vector<Float_t> listRadiusLower, listRadiusUpper;
    for (auto iEta : etaPartitions) {
      const GEMStripTopology& stripTopology = dynamic_cast<const GEMStripTopology&>(iEta->specificTopology());
      Float_t fHeight = stripTopology.stripLength();
      LocalPoint lp1(0.0, -0.5 * fHeight), lp2(0.0, 0.5 * fHeight);
      auto& surface = iEta->surface();
      GlobalPoint gp1 = surface.toGlobal(lp1), gp2 = surface.toGlobal(lp2);
      Float_t fR1 = gp1.perp(), fR2 = gp2.perp();
      Float_t fRL = std::min(fR1, fR2), fRH = std::max(fR1, fR2);
      listRadiusLower.push_back(fRL);
      listRadiusUpper.push_back(fRH);
      // For a future usage
      //std::cout << "GEO_RADIUS: " << iEta->id().chamber() << " " << iEta->id().ieta() << " "
      //  << fRL << " " << fRH << std::endl;
    }

    std::sort(listRadiusLower.begin(), listRadiusLower.end());
    std::sort(listRadiusUpper.begin(), listRadiusUpper.end());

    std::vector<Float_t>& listR =
        (chamberNo % 2 == 0 ? stationInfo.listRadiusEvenChamber_ : stationInfo.listRadiusOddChamber_);
    listR.clear();
    listR.push_back(listRadiusLower.front());
    for (int i = 1; i < (int)listRadiusLower.size(); i++) {
      listR.push_back(0.5 * (listRadiusLower[i] + listRadiusUpper[i - 1]));
    }
    listR.push_back(listRadiusUpper.back());

    if (chamberNo % 2 == 0)
      bDoneEven = true;
    if (chamberNo % 2 != 0)
      bDoneOdd = true;

    if (bDoneEven && bDoneOdd)
      break;
  }

  return 0;
}

restrictAngle()

Float_t GEMDQMBase::restrictAngle ( const Float_t  fTheta, const Float_t  fStart  )

inlineprotected

Definition at line 660 of file GEMDQMBase.h.

References createfilelist::int, and M_PI.

Referenced by GEMRecHitSource::analyze(), and GEMDigiSource::analyze().

                                                                                   {
  Float_t fLoop = (fTheta - fStart) / (2 * M_PI);
  int nLoop = (fLoop >= 0 ? (int)fLoop : (int)fLoop - 1);
  return fTheta - nLoop * 2 * M_PI;
}

SortingLayers()

int GEMDQMBase::SortingLayers ( std::vector< ME3IdsKey > &  listLayers )

protected

Definition at line 125 of file GEMDQMBase.cc.

References funct::abs(), and jetsAK4_CHS_cff::sort.

Referenced by CreateSummaryHist().

                                                              {
  std::sort(listLayers.begin(), listLayers.end(), [](ME3IdsKey key1, ME3IdsKey key2) {
    Int_t re1 = std::get<0>(key1), st1 = std::get<1>(key1), la1 = std::get<2>(key1);
    Int_t re2 = std::get<0>(key2), st2 = std::get<1>(key2), la2 = std::get<2>(key2);
    if (re1 < 0 && re2 > 0)
      return false;
    if (re1 > 0 && re2 < 0)
      return true;
    Bool_t bRes = (re1 < 0);  // == re2 < 0
    Int_t sum1 = 256 * std::abs(re1) + 16 * st1 + 1 * la1;
    Int_t sum2 = 256 * std::abs(re2) + 16 * st2 + 1 * la2;
    if (sum1 <= sum2)
      return bRes;
    return !bRes;
  });

  return 0;
}

Member Data Documentation

GEMGeometry_

const GEMGeometry* GEMDQMBase::GEMGeometry_

protected

Definition at line 579 of file GEMDQMBase.h.

Referenced by GEMRecHitSource::analyze(), GEMDigiSource::analyze(), GEMRecHitSource::bookHistograms(), GEMDigiSource::bookHistograms(), GEMDAQStatusSource::bookHistograms(), initGeometry(), and loadChambers().

geomToken_

edm::ESGetToken<GEMGeometry, MuonGeometryRecord> GEMDQMBase::geomToken_

protected

Definition at line 580 of file GEMDQMBase.h.

Referenced by initGeometry().

listChamberId_

std::vector<GEMDetId> GEMDQMBase::listChamberId_

protected

Definition at line 582 of file GEMDQMBase.h.

Referenced by GEMRecHitSource::analyze(), GEMDigiSource::analyze(), GenerateMEPerChamber(), and loadChambers().

log_category_

std::string GEMDQMBase::log_category_

Definition at line 524 of file GEMDQMBase.h.

Referenced by GEMRecHitSource::analyze(), GEMDAQStatusSource::analyze(), GEMDQMBase(), getNumEtaPartitions(), and initGeometry().

mapEtaPartition_

std::map<GEMDetId, std::vector<const GEMEtaPartition *> > GEMDQMBase::mapEtaPartition_

protected

Definition at line 583 of file GEMDQMBase.h.

Referenced by GEMRecHitSource::analyze(), GEMDigiSource::analyze(), GenerateMEPerChamber(), and loadChambers().

mapStationInfo_

std::map<ME3IdsKey, MEStationInfo> GEMDQMBase::mapStationInfo_

protected

Definition at line 594 of file GEMDQMBase.h.

Referenced by GEMRecHitSource::analyze(), GEMDigiSource::analyze(), CreateSummaryHist(), loadChambers(), GEMRecHitSource::ProcessWithMEMap3(), GEMDigiSource::ProcessWithMEMap3(), GEMDAQStatusSource::ProcessWithMEMap3(), GEMRecHitSource::ProcessWithMEMap3WithChamber(), GEMDigiSource::ProcessWithMEMap3WithChamber(), and GEMDAQStatusSource::ProcessWithMEMap3WithChamber().

mapStationToIdx_

std::map<ME3IdsKey, int> GEMDQMBase::mapStationToIdx_

protected

Definition at line 593 of file GEMDQMBase.h.

Referenced by GEMDAQStatusSource::analyze(), CreateSummaryHist(), and GEMDAQStatusSource::FillStatusSummaryPlot().

MEMap2AbsReWithEtaCheck_

std::map<ME3IdsKey, bool> GEMDQMBase::MEMap2AbsReWithEtaCheck_

protected

Definition at line 587 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

MEMap2Check_

std::map<ME2IdsKey, bool> GEMDQMBase::MEMap2Check_

protected

Definition at line 585 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

MEMap2WithEtaCheck_

std::map<ME3IdsKey, bool> GEMDQMBase::MEMap2WithEtaCheck_

protected

Definition at line 586 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

MEMap3Check_

std::map<ME3IdsKey, bool> GEMDQMBase::MEMap3Check_

protected

Definition at line 588 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

MEMap3WithChCheck_

std::map<ME4IdsKey, bool> GEMDQMBase::MEMap3WithChCheck_

protected

Definition at line 589 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

MEMap4Check_

std::map<ME4IdsKey, bool> GEMDQMBase::MEMap4Check_

protected

Definition at line 590 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

nMaxNumCh_

int GEMDQMBase::nMaxNumCh_

protected

Definition at line 592 of file GEMDQMBase.h.

Referenced by CreateSummaryHist(), and loadChambers().

nRunType_

Int_t GEMDQMBase::nRunType_

Definition at line 522 of file GEMDQMBase.h.

Referenced by GEMDAQStatusSource::analyze(), GEMRecHitSource::bookHistograms(), GEMDigiSource::bookHistograms(), GEMDAQStatusSource::bookHistograms(), and GEMDQMBase().