#include <L1Trigger/L1TCalorimeter/plugins/L1TS2PFJetInputPatternWriter.cc>

Inheritance diagram for L1TS2PFJetInputPatternWriter:

Public Member Functions
	L1TS2PFJetInputPatternWriter (const edm::ParameterSet &)

	~L1TS2PFJetInputPatternWriter () override

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

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

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 &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

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

std::vector< ESProxyIndex > 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::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase &	operator= (EDConsumerBase &&)=default

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

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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

void	beginJob () override

void	endJob () override

Private Attributes
std::vector< std::vector< uint64_t > >	data_

std::vector< int >	dataValid_

std::string	filename_

std::map< int, int >	map_

unsigned	nChan_

unsigned	nClearFrames_

unsigned	nEvents_

unsigned	nFrame_

unsigned	nFrameFile_

unsigned	nHeaderFrames_

unsigned	nLink_

unsigned	nPayloadFrames_

unsigned	nQuad_

std::string	outDir_

edm::EDGetTokenT< std::vector< l1t::PFCandidate > >	pfToken_

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

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

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

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

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 ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

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

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

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

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

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

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

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

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

Detailed Description

Description:

Implementation:

Definition at line 58 of file L1TS2PFJetInputPatternWriter.cc.

Constructor & Destructor Documentation

◆ L1TS2PFJetInputPatternWriter()

L1TS2PFJetInputPatternWriter::L1TS2PFJetInputPatternWriter ( const edm::ParameterSet & iConfig )

explicit

Definition at line 107 of file L1TS2PFJetInputPatternWriter.cc.

     : pfToken_(consumes<std::vector<l1t::PFCandidate>>(iConfig.getParameter<edm::InputTag>("pfTag"))),
       filename_(iConfig.getUntrackedParameter<std::string>("filename")),
       outDir_(iConfig.getUntrackedParameter<std::string>("outDir")),
       nChan_(iConfig.getUntrackedParameter<unsigned>("nChanPerQuad")),
       nQuad_(iConfig.getUntrackedParameter<unsigned>("nQuads")),
       nHeaderFrames_(iConfig.getUntrackedParameter<unsigned>("nHeaderFrames")),
       nPayloadFrames_(iConfig.getUntrackedParameter<unsigned>("nPayloadFrames")),
       nClearFrames_(iConfig.getUntrackedParameter<unsigned>("nClearFrames")) {
   //now do what ever initialization is needed
  
   // register what you consume and keep token for later access:
  
   nFrame_ = 0;
   nFrameFile_ = 0;
   nEvents_ = 0;
  
   nLink_ = nChan_ * nQuad_;
   data_.resize(nLink_);
   LogDebug("L1TDebug") << "Preparing for " << nLink_ << " links" << std::endl;
 }

References data_, LogDebug, nChan_, nEvents_, nFrame_, nFrameFile_, nLink_, and nQuad_.

◆ ~L1TS2PFJetInputPatternWriter()

L1TS2PFJetInputPatternWriter::~L1TS2PFJetInputPatternWriter ( )

override

Definition at line 129 of file L1TS2PFJetInputPatternWriter.cc.

                                                             {
   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)
 }

Member Function Documentation

◆ analyze()

void L1TS2PFJetInputPatternWriter::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 139 of file L1TS2PFJetInputPatternWriter.cc.

                                                                                               {
   using namespace edm;
  
   //count events
   nEvents_++;
  
   edm::Handle<std::vector<l1t::PFCandidate>> pfHandle;
   iEvent.getByToken(pfToken_, pfHandle);
   std::vector<l1t::PFCandidate> const& pfCands = *pfHandle;
  
   std::vector<l1t::PFCandidate> pfPartsA;
   std::vector<l1t::PFCandidate> pfPartsB;
  
   for (auto const& pfc : pfCands) {
     // select first two "small" regions for current fw
     if (pfc.eta() >= 0 && pfc.eta() < eta_first_region_boundary && pfc.phi() >= 0 && pfc.phi() < phi_region_boundary)
       pfPartsA.push_back(pfc);
     if (pfc.eta() >= eta_first_region_boundary && pfc.eta() < eta_second_region_boundary && pfc.phi() >= 0 &&
         pfc.phi() < phi_region_boundary)
       pfPartsB.push_back(pfc);
   }
  
   if (pfPartsA.empty() && pfPartsB.empty())
     return;
  
   if (nFrame_ == 0 || nFrameFile_ == 0) {
     //first empty frames
     while (nFrameFile_ < n_first_empty_frames) {
       dataValid_.push_back(1);
       for (unsigned iQuad = 0; iQuad < nQuad_; ++iQuad) {
         for (unsigned iChan = 0; iChan < nChan_; ++iChan) {
           uint iLink = (iQuad * nChan_) + iChan;
           data_.at(iLink).push_back(0);
         }
       }
       nFrame_++;
       nFrameFile_++;
     }
   }
  
   // loop over frames
   for (unsigned iFrame = 0; iFrame < nPayloadFrames_; ++iFrame) {
     dataValid_.push_back(1);
     // loop over links
     for (unsigned iQuad = 0; iQuad < nQuad_; ++iQuad) {
       for (unsigned iChan = 0; iChan < nChan_; ++iChan) {
         // get tower ieta, iphi for link
         uint iLink = (iQuad * nChan_) + iChan;
  
         uint64_t data = 0;
  
         if ((nFrameFile_ % n_latency_clocks) == mod_13_1) {
           if (iLink < 24 && pfPartsA.size() > iLink) {
             data |= ((uint64_t)floor(pfPartsA.at(iLink).pt() / ptLSB) & hash_bitmask_16);
             data |= ((uint64_t)floor(pfPartsA.at(iLink).phi() / phiLSB) & hash_bitmask_10) << bit_shift_phi;
             data |= ((uint64_t)floor(pfPartsA.at(iLink).eta() / etaLSB) & hash_bitmask_10) << bit_shift_eta;
           }
         }
         if ((nFrameFile_ % n_latency_clocks) == mod_13_2) {
           if (iLink < 24 && pfPartsB.size() > iLink) {
             data |= ((uint64_t)floor(pfPartsB.at(iLink).pt() / ptLSB) & hash_bitmask_16);
             data |= ((uint64_t)floor(pfPartsB.at(iLink).phi() / phiLSB) & hash_bitmask_10) << bit_shift_phi;
             data |= ((uint64_t)floor((pfPartsB.at(iLink).eta() - eta_first_region_boundary) / etaLSB) & hash_bitmask_10)
                     << bit_shift_eta;
           }
         }
         // add data to output
         data_.at(iLink).push_back(data);
       }
     }
     nFrame_++;
     nFrameFile_++;
     if (nFrame_ % framesPerFile == 0)
       nFrameFile_ = 0;
   }
 }

References bit_shift_eta, bit_shift_phi, data, data_, dataValid_, eta_first_region_boundary, eta_second_region_boundary, etaLSB, framesPerFile, hash_bitmask_10, hash_bitmask_16, iEvent, mod_13_1, mod_13_2, n_first_empty_frames, n_latency_clocks, nChan_, nEvents_, nFrame_, nFrameFile_, nPayloadFrames_, nQuad_, pfToken_, phi_region_boundary, phiLSB, ptLSB, and parallelization::uint.

◆ beginJob()

void L1TS2PFJetInputPatternWriter::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 217 of file L1TS2PFJetInputPatternWriter.cc.

217 {}

◆ endJob()

void L1TS2PFJetInputPatternWriter::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 220 of file L1TS2PFJetInputPatternWriter.cc.

                                           {
   //frames per event
   unsigned int framesPerEv = nHeaderFrames_ + nPayloadFrames_ + nClearFrames_;
  
   //events per file
   unsigned int evPerFile = floor(framesPerFile / framesPerEv);
  
   //number of output files
   unsigned int nOutFiles = ceil((float)nEvents_ / (float)evPerFile);
  
   LogDebug("L1TDebug") << "Read " << nFrame_ << " frames" << std::endl;
   LogDebug("L1TDebug") << "Read " << nEvents_ << " events" << std::endl;
   LogDebug("L1TDebug") << "Writing " << nOutFiles << " files" << std::endl;
   LogDebug("L1TDebug") << "Output directory: ./" << outDir_ << "/" << std::endl;
  
   //files
   std::vector<std::ofstream> outFiles(nOutFiles);
  
   //make output files and write to them
   for (uint itFile = 0; itFile < nOutFiles; ++itFile) {
     std::stringstream outFilename;
     outFilename << outDir_ << "/" << filename_ << "_" << itFile << ".txt";
     outFiles[itFile] = std::ofstream(outFilename.str());
     LogDebug("L1TDebug") << "Writing to file: ./" << outFilename.str() << std::endl;
  
     outFiles[itFile] << "Board SRNTY_TEST" << std::endl;
  
     // quad/chan numbers
     outFiles[itFile] << " Quad/Chan :      ";
     for (unsigned i = 0; i < nQuad_; ++i) {
       for (unsigned j = 0; j < nChan_; ++j) {
         outFiles[itFile] << "  q" << setfill('0') << setw(2) << i << "c" << j << "            ";
       }
     }
     outFiles[itFile] << std::endl;
  
     // link numbers
     outFiles[itFile] << "      Link :     ";
     for (unsigned i = 0; i < nQuad_; ++i) {
       for (unsigned j = 0; j < nChan_; ++j) {
         outFiles[itFile] << "    " << setfill('0') << setw(2) << (i * nChan_) + j << "             ";
       }
     }
  
     outFiles[itFile] << std::endl;
  
     // then the data
     unsigned iFileFrame = 0;
     for (unsigned iFrame = itFile * framesPerFile; iFrame < (itFile * framesPerFile + framesPerFile); ++iFrame) {
       if (iFrame <= nFrame_ && iFrame < (framesPerEv * nEvents_)) {
         outFiles[itFile] << "Frame " << std::dec << std::setw(4) << std::setfill('0') << iFileFrame << " : ";
         for (unsigned iQuad = 0; iQuad < nQuad_; ++iQuad) {
           for (unsigned iChan = 0; iChan < nChan_; ++iChan) {
             unsigned iLink = (iQuad * nChan_) + iChan;
             if (iLink < data_.size() && iFrame < data_.at(iLink).size()) {
               outFiles[itFile] << std::hex << ::std::setw(1) << dataValid_.at(iFrame) << "v" << std::hex
                                << std::setw(16) << std::setfill('0') << data_.at(iLink).at(iFrame) << " ";
             } else {
               outFiles[itFile] << std::hex << ::std::setw(1) << 0 << "v" << std::hex << std::setw(16)
                                << std::setfill('0') << 0 << " ";
             }
           }
         }
       }
       outFiles[itFile] << std::endl;
       iFileFrame++;
     }
     outFiles[itFile].close();
   }
 }

References reco::ceil(), data_, dataValid_, TauDecayModes::dec, filename_, framesPerFile, mps_fire::i, dqmiolumiharvest::j, LogDebug, nChan_, nClearFrames_, nEvents_, nFrame_, nHeaderFrames_, nPayloadFrames_, nQuad_, outDir_, and parallelization::uint.

◆ fillDescriptions()

void L1TS2PFJetInputPatternWriter::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 292 of file L1TS2PFJetInputPatternWriter.cc.

                                                                                               {
   edm::ParameterSetDescription desc;
   desc.addUntracked<unsigned int>("nPayloadFrames", 40);
   desc.addUntracked<unsigned int>("nHeaderFrames", 1);
   desc.add<edm::InputTag>("inputCollectionTag", edm::InputTag("l1pfCandidates", "Puppi", "IN"));
   desc.addUntracked<std::string>("filename", "pattern.txt");
   desc.addUntracked<unsigned int>("nChanPerQuad", 4);
   desc.addUntracked<unsigned int>("nClearFrames", 13);
   desc.addUntracked<unsigned int>("nQuads", 18);
   descriptions.add("l1tS2PFJetInputPatternWriter", desc);
 }