#include <Phase2TrackerDigiProducer.h>

Inheritance diagram for Phase2Tracker::Phase2TrackerDigiProducer:

Classes
class	Registry

Public Member Functions
void	beginJob () override

void	beginRun (edm::Run const &, edm::EventSetup const &) override

void	endJob () override

	Phase2TrackerDigiProducer (const edm::ParameterSet &pset)
	constructor More...

void	produce (edm::Event &, const edm::EventSetup &) override

	~Phase2TrackerDigiProducer () override
	default constructor More...

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

	~EDProducer () override

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

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

	~ProducerBase () noexcept(false) 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

ESProxyIndex const *	esGetTokenIndices (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 const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

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)

Private Attributes
const Phase2TrackerCabling *	cabling_

uint32_t	cacheId_

DetIdCollection	detids_

std::vector< Phase2TrackerDigi >	proc_work_digis_

std::vector< Registry >	proc_work_registry_

unsigned int	runNumber_

edm::EDGetTokenT< FEDRawDataCollection >	token_

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Protected Member Functions inherited from edm::ProducerBase
ProducesCollector	producesCollector ()

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

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 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<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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)

Detailed Description

Definition at line 24 of file Phase2TrackerDigiProducer.h.

Constructor & Destructor Documentation

Phase2Tracker::Phase2TrackerDigiProducer::Phase2TrackerDigiProducer ( const edm::ParameterSet & pset )

constructor

Definition at line 25 of file Phase2TrackerDigiProducer.cc.

References edm::ParameterSet::getParameter(), and token_.

       : runNumber_(0), cabling_(nullptr), cacheId_(0) {
     // define product
     produces<edm::DetSetVector<Phase2TrackerDigi>>("ProcessedRaw");
     token_ = consumes<FEDRawDataCollection>(pset.getParameter<edm::InputTag>("ProductLabel"));
   }

Phase2Tracker::Phase2TrackerDigiProducer::~Phase2TrackerDigiProducer ( )

override

default constructor

Definition at line 32 of file Phase2TrackerDigiProducer.cc.

32 {}

Member Function Documentation

void Phase2Tracker::Phase2TrackerDigiProducer::beginJob ( void )

overridevirtual

Reimplemented from edm::EDProducer.

Definition at line 34 of file Phase2TrackerDigiProducer.cc.

34 {}

void Phase2Tracker::Phase2TrackerDigiProducer::beginRun	(	edm::Run const &	run,
		edm::EventSetup const &	es
	)

overridevirtual

Reimplemented from edm::EDProducer.

Definition at line 36 of file Phase2TrackerDigiProducer.cc.

References HltBtagPostValidation_cff::c, cabling_, edm::EventSetup::get(), and edm::ESHandle< T >::product().

                                                                                      {
     // fetch cabling from event setup
     edm::ESHandle<Phase2TrackerCabling> c;
     es.get<Phase2TrackerCablingRcd>().get(c);
     cabling_ = c.product();
   }

void Phase2Tracker::Phase2TrackerDigiProducer::endJob ( void )

overridevirtual

Reimplemented from edm::EDProducer.

Definition at line 43 of file Phase2TrackerDigiProducer.cc.

43 {}

void Phase2Tracker::Phase2TrackerDigiProducer::produce	(	edm::Event &	event,
		const edm::EventSetup &	es
	)

override

Definition at line 45 of file Phase2TrackerDigiProducer.cc.

Referenced by JSONExport.JsonExport::export(), HTMLExport.HTMLExport::export(), and HTMLExport.HTMLExportStatic::export().

                                                                                   {
     // empty vectors for the next event
     proc_work_registry_.clear();
     proc_work_digis_.clear();
 
     // Retrieve FEDRawData collection
     edm::Handle<FEDRawDataCollection> buffers;
     event.getByToken(token_, buffers);
 
     // Analyze strip tracker FED buffers in data
     size_t fedIndex;
     for (fedIndex = Phase2Tracker::FED_ID_MIN; fedIndex < Phase2Tracker::CMS_FED_ID_MAX; ++fedIndex) {
       const FEDRawData& fed = buffers->FEDData(fedIndex);
       if (fed.size() != 0) {
         // construct buffer
         Phase2Tracker::Phase2TrackerFEDBuffer* buffer = nullptr;
         buffer = new Phase2Tracker::Phase2TrackerFEDBuffer(fed.data(), fed.size());
 
 #ifdef EDM_ML_DEBUG
         std::ostringstream ss;
         ss << " -------------------------------------------- " << endl;
         ss << " buffer debug ------------------------------- " << endl;
         ss << " -------------------------------------------- " << endl;
         ss << " buffer size : " << buffer->bufferSize() << endl;
         ss << " fed id      : " << fedIndex << endl;
         ss << " -------------------------------------------- " << endl;
         ss << " tracker header debug ------------------------" << endl;
         ss << " -------------------------------------------- " << endl;
         LogTrace("Phase2TrackerDigiProducer") << ss.str();
         ss.clear();
         ss.str("");
 
         Phase2TrackerFEDHeader tr_header = buffer->trackerHeader();
         ss << " Version  : " << hex << setw(2) << (int)tr_header.getDataFormatVersion() << endl;
         ss << " Mode     : " << hex << setw(2) << tr_header.getDebugMode() << endl;
         ss << " Type     : " << hex << setw(2) << (int)tr_header.getEventType() << endl;
         ss << " Readout  : " << hex << setw(2) << tr_header.getReadoutMode() << endl;
         ss << " Condition Data : " << (tr_header.getConditionData() ? "Present" : "Absent") << "\n";
         ss << " Data Type      : " << (tr_header.getDataType() ? "Real" : "Fake") << "\n";
         ss << " Status   : " << hex << setw(16) << (int)tr_header.getGlibStatusCode() << endl;
         ss << " FE stat  : ";
         for (int i = 15; i >= 0; i--) {
           if ((tr_header.frontendStatus())[i]) {
             ss << "1";
           } else {
             ss << "0";
           }
         }
         ss << endl;
         ss << " Nr CBC   : " << hex << setw(16) << (int)tr_header.getNumberOfCBC() << endl;
         ss << " CBC stat : ";
         for (int i = 0; i < tr_header.getNumberOfCBC(); i++) {
           ss << hex << setw(2) << (int)tr_header.CBCStatus()[i] << " ";
         }
         ss << endl;
         LogTrace("Phase2TrackerDigiProducer") << ss.str();
         ss.clear();
         ss.str("");
         ss << " -------------------------------------------- " << endl;
         ss << " Payload  ----------------------------------- " << endl;
         ss << " -------------------------------------------- " << endl;
 #endif
 
         // loop channels
         int ichan = 0;
         for (int ife = 0; ife < MAX_FE_PER_FED; ife++) {
           for (int icbc = 0; icbc < MAX_CBC_PER_FE; icbc++) {
             const Phase2TrackerFEDChannel& channel = buffer->channel(ichan);
             if (channel.length() > 0) {
               // get fedid from cabling
               const Phase2TrackerModule mod = cabling_->findFedCh(std::make_pair(fedIndex, ife));
               uint32_t detid = mod.getDetid();
 #ifdef EDM_ML_DEBUG
               ss << dec << " id from cabling : " << detid << endl;
               ss << dec << " reading channel : " << icbc << " on FE " << ife;
               ss << dec << " with length  : " << (int)channel.length() << endl;
 #endif
 
               // container for this channel's digis
               std::vector<Phase2TrackerDigi> stripsTop;
               std::vector<Phase2TrackerDigi> stripsBottom;
 
               // unpacking data
               Phase2TrackerFEDRawChannelUnpacker unpacker = Phase2TrackerFEDRawChannelUnpacker(channel);
               while (unpacker.hasData()) {
                 if (unpacker.stripOn()) {
                   if (unpacker.stripIndex() % 2) {
                     stripsTop.push_back(Phase2TrackerDigi((int)(STRIPS_PER_CBC * icbc + unpacker.stripIndex()) / 2, 0));
 #ifdef EDM_ML_DEBUG
                     ss << "t";
 #endif
                   } else {
                     stripsBottom.push_back(
                         Phase2TrackerDigi((int)(STRIPS_PER_CBC * icbc + unpacker.stripIndex()) / 2, 0));
 #ifdef EDM_ML_DEBUG
                     ss << "b";
 #endif
                   }
                 } else {
 #ifdef EDM_ML_DEBUG
                   ss << "_";
 #endif
                 }
                 unpacker++;
               }
 #ifdef EDM_ML_DEBUG
               ss << endl;
               LogTrace("Phase2TrackerDigiProducer") << ss.str();
               ss.clear();
               ss.str("");
 #endif
 
               // store beginning and end of this digis for this detid and add this registry to the list
               // and store data
               Registry regItemTop(detid + 1, STRIPS_PER_CBC * icbc / 2, proc_work_digis_.size(), stripsTop.size());
               proc_work_registry_.push_back(regItemTop);
               proc_work_digis_.insert(proc_work_digis_.end(), stripsTop.begin(), stripsTop.end());
               Registry regItemBottom(
                   detid + 2, STRIPS_PER_CBC * icbc / 2, proc_work_digis_.size(), stripsBottom.size());
               proc_work_registry_.push_back(regItemBottom);
               proc_work_digis_.insert(proc_work_digis_.end(), stripsBottom.begin(), stripsBottom.end());
             }
             ichan++;
           }
         }  // end loop on channels
         // store digis in edm collections
         std::sort(proc_work_registry_.begin(), proc_work_registry_.end());
         std::vector<edm::DetSet<Phase2TrackerDigi>> sorted_and_merged;
 
         edm::DetSetVector<Phase2TrackerDigi>* pr = new edm::DetSetVector<Phase2TrackerDigi>();
 
         std::vector<Registry>::iterator it = proc_work_registry_.begin(), it2 = it + 1, end = proc_work_registry_.end();
         while (it < end) {
           sorted_and_merged.push_back(edm::DetSet<Phase2TrackerDigi>(it->detid));
           std::vector<Phase2TrackerDigi>& digis = sorted_and_merged.back().data;
           // first count how many digis we have
           size_t len = it->length;
           for (it2 = it + 1; (it2 != end) && (it2->detid == it->detid); ++it2) {
             len += it2->length;
           }
           // reserve memory
           digis.reserve(len);
           // push them in
           for (it2 = it + 0; (it2 != end) && (it2->detid == it->detid); ++it2) {
             digis.insert(digis.end(), &proc_work_digis_[it2->index], &proc_work_digis_[it2->index + it2->length]);
           }
           it = it2;
         }
 
         edm::DetSetVector<Phase2TrackerDigi> proc_raw_dsv(sorted_and_merged, true);
         pr->swap(proc_raw_dsv);
         event.put(std::unique_ptr<edm::DetSetVector<Phase2TrackerDigi>>(pr), "ProcessedRaw");
         delete buffer;
       }
     }
   }