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	getIEtaFromVFATGE11 (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
std::vector< GEMChamber >	gemChambers_
const GEMGeometry *	GEMGeometry_
edm::ESGetToken< GEMGeometry, MuonGeometryRecord >	geomToken_
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_
Int_t	nNumEtaPartitionGE0_
Int_t	nNumEtaPartitionGE11_
Int_t	nNumEtaPartitionGE21_
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

typedef MEMapInfT<MEMap2Ids, ME2IdsKey> GEMDQMBase::MEMap2Inf

Definition at line 458 of file GEMDQMBase.h.

typedef MEMapInfT<MEMap3Ids, ME3IdsKey> GEMDQMBase::MEMap3Inf

Definition at line 459 of file GEMDQMBase.h.

typedef MEMapInfT<MEMap4Ids, ME4IdsKey> GEMDQMBase::MEMap4Inf

Definition at line 460 of file GEMDQMBase.h.

Member Enumeration Documentation

anonymous enum

Enumerator
GEMDQM_RUNTYPE_ONLINE
GEMDQM_RUNTYPE_OFFLINE
GEMDQM_RUNTYPE_RELVAL
GEMDQM_RUNTYPE_ALLPLOTS
GEMDQM_RUNTYPE_NONE

Definition at line 508 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 ( const edm::ParameterSet &  cfg )

explicit

Definition at line 7 of file GEMDQMBase.cc.

References edm::BeginRun, GEMDQM_RUNTYPE_ALLPLOTS, GEMDQM_RUNTYPE_OFFLINE, GEMDQM_RUNTYPE_ONLINE, GEMDQM_RUNTYPE_RELVAL, edm::ParameterSet::getUntrackedParameter(), log_category_, nNumEtaPartitionGE0_, nNumEtaPartitionGE11_, nNumEtaPartitionGE21_, 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");

  nNumEtaPartitionGE0_ = 0;
  nNumEtaPartitionGE11_ = 0;
  nNumEtaPartitionGE21_ = 0;
}

GEMDQMBase::~GEMDQMBase ( )

inlineoverride

Definition at line 506 of file GEMDQMBase.h.

{};

Member Function Documentation

template<typename T >

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

inlineprotected

Definition at line 594 of file GEMDQMBase.h.

Referenced by getNumEtaPartitions().

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

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

protected

Definition at line 142 of file GEMDQMBase.cc.

References dqm::implementation::IBooker::book2D(), GEMUtils::getSuffixName(), mps_fire::i, submitPVResolutionJobs::key, keyToLayer(), keyToRegion(), keyToStation(), label, mapStationInfo_, mapStationToIdx_, nMaxNumCh_, HLT_FULL_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;
}

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

protected

Definition at line 174 of file GEMDQMBase.cc.

References funct::abs(), GEMDetId::chamber(), gemChambers_, GEMUtils::getSuffixName(), GEMUtils::getSuffixTitle(), GEMDetId::ieta(), GEMDetId::layer(), MEMap2AbsReWithEtaCheck_, MEMap2Check_, MEMap2WithEtaCheck_, MEMap3Check_, MEMap3WithChCheck_, MEMap4Check_, ProcessWithMEMap2(), ProcessWithMEMap2AbsReWithEta(), ProcessWithMEMap2WithEta(), ProcessWithMEMap3(), ProcessWithMEMap3WithChamber(), ProcessWithMEMap4(), GEMDetId::region(), and GEMDetId::station().

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

                                                             {
  MEMap2Check_.clear();
  MEMap2WithEtaCheck_.clear();
  MEMap2AbsReWithEtaCheck_.clear();
  MEMap3Check_.clear();
  MEMap3WithChCheck_.clear();
  MEMap4Check_.clear();
  for (const auto& ch : gemChambers_) {
    GEMDetId gid = ch.id();
    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 : ch.etaPartitions()) {
      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;
}

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

inlineprotected

Definition at line 635 of file GEMDQMBase.h.

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

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

inlineprotected

Definition at line 627 of file GEMDQMBase.h.

References getIEtaFromVFATGE11().

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

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

int GEMDQMBase::getIEtaFromVFATGE11 ( const int  vfat )

inlineprotected

Definition at line 633 of file GEMDQMBase.h.

References nNumEtaPartitionGE11_.

Referenced by getIEtaFromVFAT().

{ return 8 - (vfat % nNumEtaPartitionGE11_); }

int GEMDQMBase::getMaxVFAT ( const int  station )

inlineprotected

Definition at line 603 of file GEMDQMBase.h.

References GEMeMap::maxVFatGE11_, and GEMeMap::maxVFatGE21_.

Referenced by loadChambers().

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

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

inlineprotected

Definition at line 645 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);
  const char *szRegion = (keyToRegion(key3) > 0 ? "P" : "M");
  auto nLayer = keyToLayer(key3);
  return std::string(Form("GE%i1-%s-L%i", nStation, szRegion, nLayer));
}

int GEMDQMBase::getNumEtaPartitions ( const GEMStation *  station )

protected

Definition at line 46 of file GEMDQMBase.cc.

References chambers, checkRefs(), log_category_, and GEMStation::superChambers().

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();
}

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

inlineprotected

Definition at line 612 of file GEMDQMBase.h.

References getVFATNumberGE11().

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

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

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

inlineprotected

Definition at line 622 of file GEMDQMBase.h.

References getVFATNumber(), and GEMeMap::maxChan_.

Referenced by GEMDigiSource::analyze().

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

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

inlineprotected

Definition at line 618 of file GEMDQMBase.h.

References nNumEtaPartitionGE11_.

Referenced by getVFATNumber().

                                                                                              {
  return vfat_phi * nNumEtaPartitionGE11_ + (nNumEtaPartitionGE11_ - ieta);
}

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

protected

Definition at line 31 of file GEMDQMBase.cc.

References alignCSCRings::e, GEMGeometry_, geomToken_, edm::EventSetup::getData(), and log_category_.

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

                                                        {
  GEMGeometry_ = nullptr;
  try {
    //edm::ESHandle<GEMGeometry> hGeom;
    //iSetup.get<MuonGeometryRecord>().get(hGeom);
    GEMGeometry_ = &iSetup.getData(geomToken_);
  } catch (edm::eventsetup::NoProxyException<GEMGeometry>& e) {
    edm::LogError(log_category_) << "+++ Error : GEM geometry is unavailable on event loop. +++\n";
    return -1;
  }

  return 0;
}

ME2IdsKey GEMDQMBase::key3Tokey2 ( ME3IdsKey  key )

inlineprotected

Definition at line 544 of file GEMDQMBase.h.

References keyToRegion(), and keyToStation().

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

ME3IdsKey GEMDQMBase::key4Tokey3 ( ME4IdsKey  key )

inlineprotected

Definition at line 549 of file GEMDQMBase.h.

References 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;
  };

int GEMDQMBase::keyToChamber ( ME4IdsKey  key )

inlineprotected

Definition at line 540 of file GEMDQMBase.h.

References submitPVResolutionJobs::key.

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

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

int GEMDQMBase::keyToIEta ( ME3IdsKey  key )

inlineprotected

Definition at line 541 of file GEMDQMBase.h.

References submitPVResolutionJobs::key.

Referenced by GEMRecHitSource::analyze().

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

int GEMDQMBase::keyToIEta ( ME4IdsKey  key )

inlineprotected

Definition at line 542 of file GEMDQMBase.h.

References submitPVResolutionJobs::key.

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

int GEMDQMBase::keyToLayer ( ME3IdsKey  key )

inlineprotected

Definition at line 538 of file GEMDQMBase.h.

References submitPVResolutionJobs::key.

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

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

int GEMDQMBase::keyToLayer ( ME4IdsKey  key )

inlineprotected

Definition at line 539 of file GEMDQMBase.h.

References submitPVResolutionJobs::key.

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

int GEMDQMBase::keyToRegion ( ME2IdsKey  key )

inlineprotected

Definition at line 532 of file GEMDQMBase.h.

References submitPVResolutionJobs::key.

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

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

int GEMDQMBase::keyToRegion ( ME3IdsKey  key )

inlineprotected

Definition at line 533 of file GEMDQMBase.h.

References submitPVResolutionJobs::key.

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

int GEMDQMBase::keyToRegion ( ME4IdsKey  key )

inlineprotected

Definition at line 534 of file GEMDQMBase.h.

References submitPVResolutionJobs::key.

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

int GEMDQMBase::keyToStation ( ME2IdsKey  key )

inlineprotected

Definition at line 535 of file GEMDQMBase.h.

References submitPVResolutionJobs::key.

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

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

int GEMDQMBase::keyToStation ( ME3IdsKey  key )

inlineprotected

Definition at line 536 of file GEMDQMBase.h.

References submitPVResolutionJobs::key.

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

int GEMDQMBase::keyToStation ( ME4IdsKey  key )

inlineprotected

Definition at line 537 of file GEMDQMBase.h.

References submitPVResolutionJobs::key.

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

int GEMDQMBase::loadChambers ( )

protected

Definition at line 62 of file GEMDQMBase.cc.

References gemChambers_, GEMGeometry_, getMaxVFAT(), getNumEtaPartitions(), cmsLHEtoEOSManager::l, mapStationInfo_, SiStripPI::max, GEMeMap::maxChan_, nMaxNumCh_, nNumEtaPartitionGE0_, nNumEtaPartitionGE11_, nNumEtaPartitionGE21_, readGeometryPhiInfoChamber(), readGeometryRadiusInfoChamber(), HLT_FULL_cff::region, GEMGeometry::regions(), relativeConstraints::station, and GEMGeometry::superChambers().

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

                             {
  if (GEMGeometry_ == nullptr)
    return -1;
  gemChambers_.clear();
  const std::vector<const GEMSuperChamber*>& superChambers_ = GEMGeometry_->superChambers();
  for (auto sch : superChambers_) {  // FIXME: This loop can be merged into the below loop
    int n_lay = sch->nChambers();
    for (int l = 0; l < n_lay; l++) {
      Bool_t bExist = false;
      if (not sch->chamber(l + 1))
        continue;
      for (const auto& ch : gemChambers_) {
        if (ch.id() == sch->chamber(l + 1)->id()) {
          bExist = true;
          break;
        }
      }
      if (bExist)
        continue;
      gemChambers_.push_back(*sch->chamber(l + 1));
    }
  }

  // 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 = superchambers.size();
      const int num_layers = superchambers.front()->nChambers();
      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);

      for (int layer_number = 1; layer_number <= num_layers; layer_number++) {
        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);
        readGeometryRadiusInfoChamber(station, mapStationInfo_[key3]);
        readGeometryPhiInfoChamber(station, mapStationInfo_[key3]);
      }
    }
  }

  if (mapStationInfo_.find(ME3IdsKey(-1, 0, 1)) != mapStationInfo_.end())
    nNumEtaPartitionGE0_ = mapStationInfo_[ME3IdsKey(-1, 0, 1)].nNumEtaPartitions_;
  if (mapStationInfo_.find(ME3IdsKey(-1, 1, 1)) != mapStationInfo_.end())
    nNumEtaPartitionGE11_ = mapStationInfo_[ME3IdsKey(-1, 1, 1)].nNumEtaPartitions_;
  if (mapStationInfo_.find(ME3IdsKey(-1, 2, 1)) != mapStationInfo_.end())
    nNumEtaPartitionGE21_ = mapStationInfo_[ME3IdsKey(-1, 2, 1)].nNumEtaPartitions_;

  return 0;
}

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

inlineprotectedvirtual

Reimplemented in GEMDigiSource.

Definition at line 525 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

{ return 0; };              // must be overrided

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

inlineprotectedvirtual

Reimplemented in GEMRecHitSource.

Definition at line 527 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

{ return 0; };  // must be overrided

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

inlineprotectedvirtual

Reimplemented in GEMDigiSource, and GEMRecHitSource.

Definition at line 526 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

{ return 0; };       // must be overrided

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

inlineprotectedvirtual

Reimplemented in GEMDAQStatusSource, GEMDigiSource, and GEMRecHitSource.

Definition at line 528 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

{ return 0; };              // must be overrided

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

inlineprotectedvirtual

Reimplemented in GEMDAQStatusSource, GEMDigiSource, and GEMRecHitSource.

Definition at line 530 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

{ return 0; };   // must be overrided

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

inlineprotectedvirtual

Definition at line 529 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

{ return 0; };              // must be overrided

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

Definition at line 302 of file GEMDQMBase.cc.

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

Referenced by loadChambers().

                                                                                                {
  auto listSuperChambers = station->superChambers();
  //Int_t nNumStripVFAT = stationInfo.nNumDigi_ / ( stationInfo.nMaxVFAT_ / stationInfo.nNumEtaPartitions_ );
  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_ = 1048576.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;
}

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

Definition at line 241 of file GEMDQMBase.cc.

References mps_fire::i, GEMDQMBase::MEStationInfo::listRadiusEvenChamber_, GEMDQMBase::MEStationInfo::listRadiusOddChamber_, SiStripPI::max, SiStripPI::min, PV3DBase< T, PVType, FrameType >::perp(), GEMStripTopology::stripLength(), and GEMStation::superChambers().

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;
}

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

inlineprotected

Definition at line 639 of file GEMDQMBase.h.

References 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;
}

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

protected

Definition at line 123 of file GEMDQMBase.cc.

References funct::abs().

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

std::vector<GEMChamber> GEMDQMBase::gemChambers_

protected

Definition at line 574 of file GEMDQMBase.h.

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

const GEMGeometry* GEMDQMBase::GEMGeometry_

protected

Definition at line 571 of file GEMDQMBase.h.

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

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

protected

Definition at line 572 of file GEMDQMBase.h.

Referenced by initGeometry().

std::string GEMDQMBase::log_category_

Definition at line 518 of file GEMDQMBase.h.

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

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

protected

Definition at line 585 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().

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

protected

Definition at line 584 of file GEMDQMBase.h.

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

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

protected

Definition at line 578 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

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

protected

Definition at line 576 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

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

protected

Definition at line 577 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

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

protected

Definition at line 579 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

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

protected

Definition at line 580 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

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

protected

Definition at line 581 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

int GEMDQMBase::nMaxNumCh_

protected

Definition at line 583 of file GEMDQMBase.h.

Referenced by CreateSummaryHist(), and loadChambers().

Int_t GEMDQMBase::nNumEtaPartitionGE0_

protected

Definition at line 587 of file GEMDQMBase.h.

Referenced by GEMDQMBase(), and loadChambers().

Int_t GEMDQMBase::nNumEtaPartitionGE11_

protected

Definition at line 588 of file GEMDQMBase.h.

Referenced by GEMDQMBase(), getIEtaFromVFATGE11(), getVFATNumberGE11(), and loadChambers().

Int_t GEMDQMBase::nNumEtaPartitionGE21_

protected

Definition at line 589 of file GEMDQMBase.h.

Referenced by GEMDQMBase(), and loadChambers().

Int_t GEMDQMBase::nRunType_

Definition at line 516 of file GEMDQMBase.h.

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