Inheritance diagram for L1TMuonOverlapParamsViewer:

Public Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

string	hash (void *buf, size_t len) const

	L1TMuonOverlapParamsViewer (const edm::ParameterSet &pset)

Public Member Functions inherited from edm::one::EDAnalyzer<>
	EDAnalyzer ()=default

	EDAnalyzer (const EDAnalyzer &)=delete

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

const EDAnalyzer &	operator= (const EDAnalyzer &)=delete

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const final

Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDAnalyzerBase () override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESResolverIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESResolverIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const *> const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Attributes
bool	printLayerMap

edm::ESGetToken< L1TMuonOverlapParams, L1TMuonOverlapParamsRcd >	token_

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Definition at line 21 of file L1TMuonOverlapParamsViewer.cc.

Constructor & Destructor Documentation

◆ L1TMuonOverlapParamsViewer()

L1TMuonOverlapParamsViewer::L1TMuonOverlapParamsViewer ( const edm::ParameterSet & pset )

inlineexplicit

Definition at line 30 of file L1TMuonOverlapParamsViewer.cc.

References deDxTools::esConsumes().

                                                                    : token_{esConsumes()} {
     printLayerMap = pset.getUntrackedParameter<bool>("printLayerMap", false);
   }

Member Function Documentation

◆ analyze()

void L1TMuonOverlapParamsViewer::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	evSetup
	)

overridevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 68 of file L1TMuonOverlapParamsViewer.cc.

                                                                                              {
   // Pull the config from the ES
   L1TMuonOverlapParams const &ptr1 = evSetup.getData(token_);
 
   cout << "Some fields in L1TMuonOverlapParamsParams: " << endl;
 
   cout << " fwVersion() = " << ptr1.fwVersion() << endl;
   cout << " nPdfAddrBits() = " << ptr1.nPdfAddrBits() << endl;
   cout << " nPdfValBits() = " << ptr1.nPdfValBits() << endl;
   cout << " nHitsPerLayer() = " << ptr1.nHitsPerLayer() << endl;
   cout << " nPhiBits() = " << ptr1.nPhiBits() << endl;
   cout << " nPhiBins() = " << ptr1.nPhiBins() << endl;
   cout << " nRefHits() = " << ptr1.nRefHits() << endl;
   cout << " nTestRefHits() = " << ptr1.nTestRefHits() << endl;
   cout << " nProcessors() = " << ptr1.nProcessors() << endl;
   cout << " nLogicRegions() = " << ptr1.nLogicRegions() << endl;
   cout << " nInputs() = " << ptr1.nInputs() << endl;
   cout << " nLayers() = " << ptr1.nLayers() << endl;
   cout << " nRefLayers() = " << ptr1.nRefLayers() << endl;
   cout << " nGoldenPatterns() = " << ptr1.nGoldenPatterns() << endl;
 
   const std::vector<int> *gp = ptr1.generalParams();
   cout << " number of general parameters: = " << gp->size() << endl;
   cout << "  ";
   for (auto a : *gp)
     cout << a << ", ";
   cout << endl;
 
   const std::vector<L1TMuonOverlapParams::LayerMapNode> *lm = ptr1.layerMap();
   if (!lm->empty()) {
     cout << " layerMap() =              [" << lm->size() << "] ";
     L1TMuonOverlapParams::LayerMapNode *lm_ = new L1TMuonOverlapParams::LayerMapNode[lm->size()];
     for (unsigned int i = 0; i < lm->size(); i++)
       lm_[i] = (*lm)[i];
     cout << hash(lm_, sizeof(L1TMuonOverlapParams::LayerMapNode) * (lm->size())) << endl;
     if (printLayerMap) {
       cout << sizeof(L1TMuonOverlapParams::LayerMapNode) << endl;
       for (unsigned int i = 0; i < lm->size(); i++) {
         cout << "  [" << i << "]: hwNumber = " << lm_[i].hwNumber << " logicNumber = " << lm_[i].logicNumber
              << " bendingLayer = " << lm_[i].bendingLayer << " connectedToLayer = " << lm_[i].connectedToLayer << " ("
              << flush;
         char *n = (char *)(&(lm_[i]));
         for (unsigned int j = 0; j < sizeof(L1TMuonOverlapParams::LayerMapNode); j++)
           cout << "0x" << hex << int(*(n + j)) << dec << ", ";
         cout << endl;
       }
       // hash( (void*)(&(lm_[i])), sizeof(L1TMuonOverlapParams::LayerMapNode) ) <<endl;
     }
     delete[] lm_;
   } else {
     cout << " layerMap() =              [0] " << endl;
   }
 
   const std::vector<L1TMuonOverlapParams::RefLayerMapNode> *rlm = ptr1.refLayerMap();
   if (!rlm->empty()) {
     cout << " refLayerMap() =           [" << rlm->size() << "] ";
     L1TMuonOverlapParams::RefLayerMapNode *rlm_ = new L1TMuonOverlapParams::RefLayerMapNode[rlm->size()];
     for (unsigned int i = 0; i < rlm->size(); i++)
       rlm_[i] = (*rlm)[i];
     cout << hash(rlm_, sizeof(L1TMuonOverlapParams::RefLayerMapNode) * (rlm->size())) << endl;
     delete[] rlm_;
   } else {
     cout << " refLayerMap() =           [0] " << endl;
   }
 
   const std::vector<L1TMuonOverlapParams::RefHitNode> *rhn = ptr1.refHitMap();
   if (!rhn->empty()) {
     cout << " refHitMap() =             [" << rhn->size() << "] ";
     L1TMuonOverlapParams::RefHitNode *rhn_ = new L1TMuonOverlapParams::RefHitNode[rhn->size()];
     for (unsigned int i = 0; i < rhn->size(); i++)
       rhn_[i] = (*rhn)[i];
     cout << hash(rhn_, sizeof(L1TMuonOverlapParams::RefHitNode) * (rhn->size())) << endl;
     delete[] rhn_;
   } else {
     cout << " refHitMap() =             [0] " << endl;
   }
 
   const std::vector<int> *gpsm = ptr1.globalPhiStartMap();
   if (!gpsm->empty()) {
     cout << " globalPhiStartMap() =     [" << gpsm->size() << "] ";
     int gpsm_[gpsm->size()];
     for (unsigned int i = 0; i < gpsm->size(); i++)
       gpsm_[i] = (*gpsm)[i];
     cout << hash(gpsm_, sizeof(int) * (gpsm->size())) << endl;
   } else {
     cout << " globalPhiStartMap() =     [0] " << endl;
   }
 
   const std::vector<L1TMuonOverlapParams::LayerInputNode> *lim = ptr1.layerInputMap();
   if (!lim->empty()) {
     cout << " layerInputMap() =         [" << lim->size() << "] ";
     L1TMuonOverlapParams::LayerInputNode *lim_ = new L1TMuonOverlapParams::LayerInputNode[lim->size()];
     for (unsigned int i = 0; i < lim->size(); i++)
       lim_[i] = (*lim)[i];
     cout << hash(lim_, sizeof(L1TMuonOverlapParams::LayerInputNode) * (lim->size())) << endl;
     delete[] lim_;
   } else {
     cout << " layerInputMap() =         [0] " << endl;
   }
 
   const std::vector<int> *css = ptr1.connectedSectorsStart();
   if (!css->empty()) {
     cout << " connectedSectorsStart() = [" << css->size() << "] ";
     int css_[css->size()];
     for (unsigned int i = 0; i < css->size(); i++)
       css_[i] = (*css)[i];
     cout << hash(css_, sizeof(int) * (css->size())) << endl;
   } else {
     cout << " connectedSectorsStart() = [0] " << endl;
   }
 
   const std::vector<int> *cse = ptr1.connectedSectorsEnd();
   if (!cse->empty()) {
     cout << " connectedSectorsEnd() = [" << cse->size() << "] ";
     int cse_[cse->size()];
     for (unsigned int i = 0; i < cse->size(); i++)
       cse_[i] = (*cse)[i];
     cout << hash(cse_, sizeof(int) * (cse->size())) << endl;
   } else {
     cout << " connectedSectorsEnd() = [0] " << endl;
   }
 
   const l1t::LUT *clut = ptr1.chargeLUT();
   if (clut->maxSize()) {
     cout << " chargeLUT =      [" << clut->maxSize() << "] ";
     int clut_[clut->maxSize()];
     for (unsigned int i = 0; i < clut->maxSize(); i++)
       clut_[i] = clut->data(i);
     cout << hash(clut_, sizeof(int) * (clut->maxSize())) << endl;
   } else {
     cout << " chargeLUT =      [0] " << endl;
   }
 
   const l1t::LUT *elut = ptr1.etaLUT();
   if (elut->maxSize()) {
     cout << " etaLUT =         [" << elut->maxSize() << "] ";
     int elut_[elut->maxSize()];
     for (unsigned int i = 0; i < elut->maxSize(); i++)
       elut_[i] = elut->data(i);
     cout << hash(elut_, sizeof(int) * (elut->maxSize())) << endl;
   } else {
     cout << " chargeLUT =      [0] " << endl;
   }
 
   const l1t::LUT *ptlut = ptr1.ptLUT();
   if (ptlut->maxSize()) {
     cout << " ptLUT =          [" << ptlut->maxSize() << "] " << flush;
     int ptlut_[ptlut->maxSize()];
     for (unsigned int i = 0; i < ptlut->maxSize(); i++)
       ptlut_[i] = ptlut->data(i);
     cout << hash(ptlut_, sizeof(int) * (ptlut->maxSize())) << endl;
   } else {
     cout << " ptLUT =          [0] " << endl;
   }
 
   const l1t::LUT *plut = ptr1.pdfLUT();
   if (plut->maxSize()) {
     cout << " pdfLUT =         [" << plut->maxSize() << "] " << flush;
     int plut_[plut->maxSize()];
     for (unsigned int i = 0; i < plut->maxSize(); i++)
       plut_[i] = plut->data(i);
     cout << hash(plut_, sizeof(int) * (plut->maxSize())) << endl;
   } else {
     cout << " pdfLUT =         [0] " << endl;
   }
 
   const l1t::LUT *mlut = ptr1.meanDistPhiLUT();
   if (mlut->maxSize()) {
     cout << " meanDistPhiLUT = [" << mlut->maxSize() << "] " << flush;
     int mlut_[mlut->maxSize()];
     for (unsigned int i = 0; i < mlut->maxSize(); i++)
       mlut_[i] = mlut->data(i);
     cout << hash(mlut_, sizeof(int) * (mlut->maxSize())) << endl;
   } else {
     cout << " meanDistPhiLUT = [0] " << endl;
   }
 }

◆ hash()

string L1TMuonOverlapParamsViewer::hash	(	void *	buf,
		size_t	len
	)		const

Definition at line 40 of file L1TMuonOverlapParamsViewer.cc.

References visDQMUpload::buf, EVP_MD_CTX_free, EVP_MD_CTX_new, Exception, cond::hash, mps_fire::i, cms::openssl_init(), AlCaHLTBitMon_QueryRunRegistry::string, and createJobs::tmp.

                                                                    {
   cms::openssl_init();
   EVP_MD_CTX *mdctx = EVP_MD_CTX_new();
   const EVP_MD *md = EVP_get_digestbyname("SHA1");
   if (!EVP_DigestInit_ex(mdctx, md, nullptr))
     throw cms::Exception("L1TCaloParamsViewer::hash") << "SHA1 initialization error";
 
   if (!EVP_DigestUpdate(mdctx, buf, len))
     throw cms::Exception("L1TCaloParamsViewer::hash") << "SHA1 processing error";
 
   unsigned char hash[EVP_MAX_MD_SIZE];
   unsigned int md_len = 0;
   if (!EVP_DigestFinal_ex(mdctx, hash, &md_len))
     throw cms::Exception("L1TCaloParamsViewer::hash") << "SHA1 finalization error";
 
   EVP_MD_CTX_free(mdctx);
 
   // re-write bytes in hex
   char tmp[EVP_MAX_MD_SIZE * 2 + 1];
   if (md_len > 20)
     md_len = 20;
   for (unsigned int i = 0; i < md_len; i++)
     ::sprintf(&tmp[i * 2], "%02x", hash[i]);
 
   tmp[md_len * 2] = 0;
   return string(tmp);
 }