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
typedef MEMapInfT< MEMap5Ids, ME5IdsKey >	MEMap5Inf
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	getIdxModule (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)
std::string	getNameDirLayer (ME4IdsKey key4)
int	getNumEtaPartitions (const GEMStation *)
int	getNumModule (const int)
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)
ME4IdsKey	key5Tokey4 (ME5IdsKey key)
int	keyToChamber (ME4IdsKey key)
int	keyToChamber (ME5IdsKey key)
int	keyToIEta (ME4IdsKey key)
int	keyToIEta (ME5IdsKey key)
int	keyToLayer (ME3IdsKey key)
int	keyToLayer (ME4IdsKey key)
int	keyToLayer (ME5IdsKey key)
int	keyToModule (ME4IdsKey key)
int	keyToModule (ME5IdsKey key)
int	keyToRegion (ME2IdsKey key)
int	keyToRegion (ME3IdsKey key)
int	keyToRegion (ME4IdsKey key)
int	keyToRegion (ME5IdsKey key)
int	keyToStation (ME2IdsKey key)
int	keyToStation (ME3IdsKey key)
int	keyToStation (ME4IdsKey key)
int	keyToStation (ME5IdsKey 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	ProcessWithMEMap4 (BookingHelper &bh, ME4IdsKey key)
virtual int	ProcessWithMEMap4WithChamber (BookingHelper &bh, ME4IdsKey key)
virtual int	ProcessWithMEMap5 (BookingHelper &bh, ME5IdsKey key)
virtual int	ProcessWithMEMap5WithChamber (BookingHelper &bh, ME5IdsKey key)
Float_t	restrictAngle (const Float_t fTheta, const Float_t fStart)
int	SortingLayers (std::vector< ME4IdsKey > &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< ME4IdsKey, 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 >	MEMap4Check_
std::map< ME4IdsKey, bool >	MEMap4WithChCheck_
std::map< ME5IdsKey, bool >	MEMap5Check_
std::map< ME5IdsKey, bool >	MEMap5WithChCheck_
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 473 of file GEMDQMBase.h.

MEMap3Inf

typedef MEMapInfT<MEMap3Ids, ME3IdsKey> GEMDQMBase::MEMap3Inf

Definition at line 474 of file GEMDQMBase.h.

MEMap4Inf

typedef MEMapInfT<MEMap4Ids, ME4IdsKey> GEMDQMBase::MEMap4Inf

Definition at line 475 of file GEMDQMBase.h.

MEMap5Inf

typedef MEMapInfT<MEMap5Ids, ME5IdsKey> GEMDQMBase::MEMap5Inf

Definition at line 476 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 537 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 535 of file GEMDQMBase.h.

{};

Member Function Documentation

checkRefs()

template<typename T >

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

inlineprotected

Definition at line 640 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 150 of file GEMDQMBase.cc.

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

Referenced by GEMDAQStatusSource::bookHistograms().

                                                                                              {
  std::vector<ME4IdsKey> listLayers;
  for (auto const& [key3, stationInfo] : mapStationInfo_) {
    for (int module_number = 1; module_number <= stationInfo.nNumModules_; module_number++) {
      ME4IdsKey key4{keyToRegion(key3), keyToStation(key3), keyToLayer(key3), module_number};
      listLayers.push_back(key4);  // Note: Not only count layers but also modules
    }
  }
  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];
    ME3IdsKey key3 = key4Tokey3(key);

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

  return h2Res;
}

GenerateMEPerChamber()

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

protected

Definition at line 195 of file GEMDQMBase.cc.

References funct::abs(), GEMUtils::getSuffixName(), GEMUtils::getSuffixTitle(), l1tTowerCalibrationProducer_cfi::iEta, GEMDetId::ieta(), listChamberId_, mapEtaPartition_, mapStationInfo_, MEMap2AbsReWithEtaCheck_, MEMap2Check_, MEMap2WithEtaCheck_, MEMap3Check_, MEMap4Check_, MEMap4WithChCheck_, MEMap5Check_, MEMap5WithChCheck_, ProcessWithMEMap2(), ProcessWithMEMap2AbsReWithEta(), ProcessWithMEMap2WithEta(), ProcessWithMEMap3(), ProcessWithMEMap4(), ProcessWithMEMap4WithChamber(), ProcessWithMEMap5(), and ProcessWithMEMap5WithChamber().

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

                                                             {
  MEMap2Check_.clear();
  MEMap3Check_.clear();
  MEMap4Check_.clear();
  MEMap5Check_.clear();
  MEMap2WithEtaCheck_.clear();
  MEMap2AbsReWithEtaCheck_.clear();
  MEMap4WithChCheck_.clear();
  MEMap5WithChCheck_.clear();
  for (auto gid : listChamberId_) {
    ME2IdsKey key2{gid.region(), gid.station()};
    ME3IdsKey key3{gid.region(), gid.station(), gid.layer()};
    const auto num_mod = mapStationInfo_[key3].nNumModules_;
    for (int module_number = 1; module_number <= num_mod; module_number++) {
      ME4IdsKey key4{gid.region(), gid.station(), gid.layer(), module_number};
      ME4IdsKey key4WithChamber{gid.region(), gid.station(), gid.layer(), gid.chamber()};
      ME5IdsKey key5WithChamber{gid.region(), gid.station(), gid.layer(), module_number, 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 (!MEMap4Check_[key4]) {
        Int_t nLa = gid.layer();
        TString strSuffixCh = Form("-L%i", nLa);
        if (mapStationInfo_[key3].nNumModules_ > 1)
          strSuffixCh = Form("-L%i-M%i", nLa, module_number);
        auto strSuffixName = GEMUtils::getSuffixName(key2) + strSuffixCh;
        auto strSuffixTitle = GEMUtils::getSuffixTitle(key2) + strSuffixCh;
        BookingHelper bh4(ibooker, strSuffixName, strSuffixTitle);
        ProcessWithMEMap4(bh4, key4);
        MEMap4Check_[key4] = true;
      }
      if (!MEMap4WithChCheck_[key4WithChamber]) {
        Int_t nCh = gid.chamber();
        Int_t nLa = gid.layer();
        char cLS = (nCh % 2 == 0 ? 'L' : 'S');  // FIXME: Is it general enough?
        TString strSuffixCh = Form("-%02iL%i-%c", nCh, nLa, cLS);
        auto strSuffixName = GEMUtils::getSuffixName(key2) + strSuffixCh;
        auto strSuffixTitle = GEMUtils::getSuffixTitle(key2) + strSuffixCh;
        BookingHelper bh4Ch(ibooker, strSuffixName, strSuffixTitle);
        ProcessWithMEMap4WithChamber(bh4Ch, key4WithChamber);
        MEMap4WithChCheck_[key4WithChamber] = true;
      }
      if (!MEMap5WithChCheck_[key5WithChamber]) {
        Int_t nCh = gid.chamber();
        Int_t nLa = gid.layer();
        char cLS = (nCh % 2 == 0 ? 'L' : 'S');  // FIXME: Is it general enough?
        TString strSuffixCh = Form("-%02iL%i-%c", nCh, nLa, cLS);
        if (mapStationInfo_[key3].nNumModules_ > 1)
          strSuffixCh = Form("-%02iL%i-M%i-%c", nCh, nLa, module_number, cLS);
        auto strSuffixName = GEMUtils::getSuffixName(key2) + strSuffixCh;
        auto strSuffixTitle = GEMUtils::getSuffixTitle(key2) + strSuffixCh;
        BookingHelper bh5Ch(ibooker, strSuffixName, strSuffixTitle);
        ProcessWithMEMap5WithChamber(bh5Ch, key5WithChamber);
        MEMap5WithChCheck_[key5WithChamber] = true;
      }
      for (auto iEta : mapEtaPartition_[gid]) {
        GEMDetId eId = iEta->id();
        ME5IdsKey key5{gid.region(), gid.station(), gid.layer(), module_number, eId.ieta()};
        ME3IdsKey key2WithEta{gid.region(), gid.station(), eId.ieta()};
        ME3IdsKey key2AbsReWithEta{std::abs(gid.region()), gid.station(), eId.ieta()};
        if (!MEMap5Check_[key5]) {
          auto strSuffixName = GEMUtils::getSuffixName(key3) + Form("-E%02i", eId.ieta());
          auto strSuffixTitle = GEMUtils::getSuffixTitle(key3) + Form("-E%02i", eId.ieta());
          BookingHelper bh5(ibooker, strSuffixName, strSuffixTitle);
          ProcessWithMEMap5(bh5, key5);
          MEMap5Check_[key5] = 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 719 of file GEMDQMBase.h.

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

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

getIdxModule()

int GEMDQMBase::getIdxModule ( const int  station, const int  chamberType  )

inlineprotected

Definition at line 671 of file GEMDQMBase.h.

References nano_mu_digi_cff::chamberType, and relativeConstraints::station.

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

                                                                            {
  if (station == 0)
    return 1;
  if (station == 1)
    return 1;
  else if (station == 2)
    return chamberType - 20;
  else
    return -1;
}

getIEtaFromVFAT()

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

inlineprotected

Definition at line 697 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 707 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 711 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 715 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 649 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_ / 2;
  else
    return -1;
}

getNameDirLayer() [1/2]

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

inlineprotected

Definition at line 729 of file GEMDQMBase.h.

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

Referenced by GEMRecHitSource::ProcessWithMEMap4WithChamber(), GEMDigiSource::ProcessWithMEMap5WithChamber(), and GEMDAQStatusSource::ProcessWithMEMap5WithChamber().

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

getNameDirLayer() [2/2]

std::string GEMDQMBase::getNameDirLayer ( ME4IdsKey  key4 )

inlineprotected

Definition at line 736 of file GEMDQMBase.h.

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

                                                           {
  auto nStation = keyToStation(key4);
  char cRegion = (keyToRegion(key4) > 0 ? 'P' : 'M');
  auto nLayer = keyToLayer(key4);
  if (nStation == 2) {
    auto nModule = keyToModule(key4);
    return std::string(Form("GE%i1-%c-L%i-M%i", nStation, cRegion, nLayer, nModule));
  }
  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();
}

getNumModule()

int GEMDQMBase::getNumModule ( const int  station )

inlineprotected

Definition at line 660 of file GEMDQMBase.h.

References relativeConstraints::station.

Referenced by loadChambers().

                                                     {
  if (station == 0)
    return 1;
  if (station == 1)
    return 1;
  else if (station == 2)
    return 4;
  else
    return -1;
}

getVFATNumber()

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

inlineprotected

Definition at line 682 of file GEMDQMBase.h.

References getVFATNumberGE11(), hcalRecHitTable_cff::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 692 of file GEMDQMBase.h.

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

                                                                                            {
  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 688 of file GEMDQMBase.h.

References hcalRecHitTable_cff::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 581 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 586 of file GEMDQMBase.h.

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

Referenced by GEMRecHitSource::analyze(), CreateSummaryHist(), GEMDigiSource::ProcessWithMEMap4(), GEMDAQStatusSource::ProcessWithMEMap4(), GEMRecHitSource::ProcessWithMEMap4WithChamber(), GEMDigiSource::ProcessWithMEMap5WithChamber(), and GEMDAQStatusSource::ProcessWithMEMap5WithChamber().

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

key5Tokey4()

ME4IdsKey GEMDQMBase::key5Tokey4 ( ME5IdsKey  key )

inlineprotected

Definition at line 591 of file GEMDQMBase.h.

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

Referenced by GEMDAQStatusSource::FillStatusSummaryPlot(), GEMDigiSource::ProcessWithMEMap5WithChamber(), and GEMDAQStatusSource::ProcessWithMEMap5WithChamber().

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

keyToChamber() [1/2]

int GEMDQMBase::keyToChamber ( ME4IdsKey  key )

inlineprotected

Definition at line 576 of file GEMDQMBase.h.

References crabWrapper::key.

Referenced by GEMDAQStatusSource::FillStatusSummaryPlot().

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

keyToChamber() [2/2]

int GEMDQMBase::keyToChamber ( ME5IdsKey  key )

inlineprotected

Definition at line 577 of file GEMDQMBase.h.

References crabWrapper::key.

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

keyToIEta() [1/2]

int GEMDQMBase::keyToIEta ( ME4IdsKey  key )

inlineprotected

Definition at line 578 of file GEMDQMBase.h.

References crabWrapper::key.

Referenced by GEMRecHitSource::analyze().

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

keyToIEta() [2/2]

int GEMDQMBase::keyToIEta ( ME5IdsKey  key )

inlineprotected

Definition at line 579 of file GEMDQMBase.h.

References crabWrapper::key.

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

keyToLayer() [1/3]

int GEMDQMBase::keyToLayer ( ME3IdsKey  key )

inlineprotected

Definition at line 571 of file GEMDQMBase.h.

References crabWrapper::key.

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

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

keyToLayer() [2/3]

int GEMDQMBase::keyToLayer ( ME4IdsKey  key )

inlineprotected

Definition at line 572 of file GEMDQMBase.h.

References crabWrapper::key.

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

keyToLayer() [3/3]

int GEMDQMBase::keyToLayer ( ME5IdsKey  key )

inlineprotected

Definition at line 573 of file GEMDQMBase.h.

References crabWrapper::key.

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

keyToModule() [1/2]

int GEMDQMBase::keyToModule ( ME4IdsKey  key )

inlineprotected

Definition at line 574 of file GEMDQMBase.h.

References crabWrapper::key.

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

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

keyToModule() [2/2]

int GEMDQMBase::keyToModule ( ME5IdsKey  key )

inlineprotected

Definition at line 575 of file GEMDQMBase.h.

References crabWrapper::key.

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

keyToRegion() [1/4]

int GEMDQMBase::keyToRegion ( ME2IdsKey  key )

inlineprotected

Definition at line 563 of file GEMDQMBase.h.

References crabWrapper::key.

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

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

keyToRegion() [2/4]

int GEMDQMBase::keyToRegion ( ME3IdsKey  key )

inlineprotected

Definition at line 564 of file GEMDQMBase.h.

References crabWrapper::key.

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

keyToRegion() [3/4]

int GEMDQMBase::keyToRegion ( ME4IdsKey  key )

inlineprotected

Definition at line 565 of file GEMDQMBase.h.

References crabWrapper::key.

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

keyToRegion() [4/4]

int GEMDQMBase::keyToRegion ( ME5IdsKey  key )

inlineprotected

Definition at line 566 of file GEMDQMBase.h.

References crabWrapper::key.

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

keyToStation() [1/4]

int GEMDQMBase::keyToStation ( ME2IdsKey  key )

inlineprotected

Definition at line 567 of file GEMDQMBase.h.

References crabWrapper::key.

Referenced by CreateSummaryHist(), getNameDirLayer(), key3Tokey2(), key4Tokey3(), key5Tokey4(), GEMRecHitSource::ProcessWithMEMap3(), and GEMRecHitSource::ProcessWithMEMap4WithChamber().

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

keyToStation() [2/4]

int GEMDQMBase::keyToStation ( ME3IdsKey  key )

inlineprotected

Definition at line 568 of file GEMDQMBase.h.

References crabWrapper::key.

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

keyToStation() [3/4]

int GEMDQMBase::keyToStation ( ME4IdsKey  key )

inlineprotected

Definition at line 569 of file GEMDQMBase.h.

References crabWrapper::key.

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

keyToStation() [4/4]

int GEMDQMBase::keyToStation ( ME5IdsKey  key )

inlineprotected

Definition at line 570 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(), getNumModule(), l1tTowerCalibrationProducer_cfi::iEta, listChamberId_, mapEtaPartition_, mapStationInfo_, SiStripPI::max, GEMeMap::maxChan_, nMaxNumCh_, readGeometryPhiInfoChamber(), readGeometryRadiusInfoChamber(), nano_mu_digi_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 num_mod = getNumModule(station->station());
      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 strip1st = (station_number == 2 ? 1 : 0);   // the index of the first strip
      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_mod,
                                              num_etas,
                                              num_vfat,
                                              strip1st,
                                              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 554 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 556 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 555 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

{ return 0; };       // must be overrided

ProcessWithMEMap3()

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

inlineprotectedvirtual

Reimplemented in GEMDigiSource, and GEMRecHitSource.

Definition at line 557 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

{ return 0; };              // must be overrided

ProcessWithMEMap4()

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

inlineprotectedvirtual

Reimplemented in GEMDAQStatusSource, and GEMDigiSource.

Definition at line 558 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

{ return 0; };              // must be overrided

ProcessWithMEMap4WithChamber()

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

inlineprotectedvirtual

Reimplemented in GEMRecHitSource.

Definition at line 560 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

{ return 0; };   // must be overrided

ProcessWithMEMap5()

virtual int GEMDQMBase::ProcessWithMEMap5 ( BookingHelper &  bh, ME5IdsKey  key  )

inlineprotectedvirtual

Definition at line 559 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

{ return 0; };              // must be overrided

ProcessWithMEMap5WithChamber()

virtual int GEMDQMBase::ProcessWithMEMap5WithChamber ( BookingHelper &  bh, ME5IdsKey  key  )

inlineprotectedvirtual

Reimplemented in GEMDAQStatusSource, and GEMDigiSource.

Definition at line 561 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

{ return 0; };   // must be overrided

readGeometryPhiInfoChamber()

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

Definition at line 354 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 293 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(), jetUpdater_cfi::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 723 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< ME4IdsKey > &  listLayers )

protected

Definition at line 129 of file GEMDQMBase.cc.

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

Referenced by CreateSummaryHist().

                                                              {
  std::sort(listLayers.begin(), listLayers.end(), [](ME4IdsKey key1, ME4IdsKey key2) {
    Int_t re1 = std::get<0>(key1), re2 = std::get<0>(key2);
    Int_t st1 = std::get<1>(key1), st2 = std::get<1>(key2);
    Int_t la1 = std::get<2>(key1), la2 = std::get<2>(key2);
    Int_t mo1 = std::get<3>(key1), mo2 = std::get<3>(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 = 4096 * std::abs(re1) + 256 * st1 + 16 * la1 + mo1;
    Int_t sum2 = 4096 * std::abs(re2) + 256 * st2 + 16 * la2 + mo2;
    if (sum1 <= sum2)
      return bRes;
    return !bRes;
  });

  return 0;
}

Member Data Documentation

GEMGeometry_

const GEMGeometry* GEMDQMBase::GEMGeometry_

protected

Definition at line 618 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 619 of file GEMDQMBase.h.

Referenced by initGeometry().

listChamberId_

std::vector<GEMDetId> GEMDQMBase::listChamberId_

protected

Definition at line 621 of file GEMDQMBase.h.

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

log_category_

std::string GEMDQMBase::log_category_

Definition at line 547 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 622 of file GEMDQMBase.h.

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

mapStationInfo_

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

protected

Definition at line 634 of file GEMDQMBase.h.

Referenced by GEMRecHitSource::analyze(), GEMDigiSource::analyze(), GEMDAQStatusSource::analyze(), CreateSummaryHist(), GenerateMEPerChamber(), loadChambers(), GEMRecHitSource::ProcessWithMEMap3(), GEMDigiSource::ProcessWithMEMap3(), GEMDigiSource::ProcessWithMEMap4(), GEMDAQStatusSource::ProcessWithMEMap4(), GEMRecHitSource::ProcessWithMEMap4WithChamber(), GEMDigiSource::ProcessWithMEMap5WithChamber(), and GEMDAQStatusSource::ProcessWithMEMap5WithChamber().

mapStationToIdx_

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

protected

Definition at line 635 of file GEMDQMBase.h.

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

MEMap2AbsReWithEtaCheck_

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

protected

Definition at line 626 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

MEMap2Check_

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

protected

Definition at line 624 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

MEMap2WithEtaCheck_

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

protected

Definition at line 625 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

MEMap3Check_

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

protected

Definition at line 627 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

MEMap4Check_

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

protected

Definition at line 628 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

MEMap4WithChCheck_

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

protected

Definition at line 629 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

MEMap5Check_

std::map<ME5IdsKey, bool> GEMDQMBase::MEMap5Check_

protected

Definition at line 631 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

MEMap5WithChCheck_

std::map<ME5IdsKey, bool> GEMDQMBase::MEMap5WithChCheck_

protected

Definition at line 630 of file GEMDQMBase.h.

Referenced by GenerateMEPerChamber().

nMaxNumCh_

int GEMDQMBase::nMaxNumCh_

protected

Definition at line 633 of file GEMDQMBase.h.

Referenced by CreateSummaryHist(), and loadChambers().

nRunType_

Int_t GEMDQMBase::nRunType_

Definition at line 545 of file GEMDQMBase.h.

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