#include <SiPixelRawToDigi.h>

Inheritance diagram for SiPixelRawToDigi:

Public Member Functions
void	produce (edm::Event &, const edm::EventSetup &) override
	get data, convert to digis attach againe to Event More...

	SiPixelRawToDigi (const edm::ParameterSet &)
	ctor More...

	~SiPixelRawToDigi () override
	dtor More...

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

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

Private Attributes
const SiPixelQuality *	badPixelInfo_

std::unique_ptr< SiPixelFedCablingTree >	cabling_

std::string	cablingMapLabel

edm::ParameterSet	config_

bool	debug

std::vector< unsigned int >	fedIds

TH1D *	hCPU

TH1D *	hDigi

bool	includeErrors

edm::InputTag	label

int	ndigis

int	nwords

edm::ESWatcher< SiPixelQualityRcd >	qualityWatcher

edm::ESWatcher< SiPixelFedCablingMapRcd >	recordWatcher

PixelUnpackingRegions *	regions_

edm::EDGetTokenT< FEDRawDataCollection >	tFEDRawDataCollection

std::unique_ptr< edm::CPUTimer >	theTimer

std::vector< int >	tkerrorlist

bool	usePhase1

bool	usePilotBlade

bool	useQuality

std::vector< int >	usererrorlist

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

Definition at line 26 of file SiPixelRawToDigi.h.

Constructor & Destructor Documentation

SiPixelRawToDigi::SiPixelRawToDigi ( const edm::ParameterSet & conf )

explicit

ctor

Definition at line 45 of file SiPixelRawToDigi.cc.

References cablingMapLabel, config_, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNames(), edm::ParameterSet::getUntrackedParameter(), hCPU, hDigi, includeErrors, ndigis, nwords, regions_, AlCaHLTBitMon_QueryRunRegistry::string, tFEDRawDataCollection, theTimer, ecalMatacq_cfi::timing, tkerrorlist, usePhase1, usePilotBlade, useQuality, and usererrorlist.

     : config_(conf), badPixelInfo_(nullptr), regions_(nullptr), hCPU(nullptr), hDigi(nullptr) {
   includeErrors = config_.getParameter<bool>("IncludeErrors");
   useQuality = config_.getParameter<bool>("UseQualityInfo");
 
   tkerrorlist = config_.getParameter<std::vector<int>>("ErrorList");
   usererrorlist = config_.getParameter<std::vector<int>>("UserErrorList");
 
   tFEDRawDataCollection = consumes<FEDRawDataCollection>(config_.getParameter<edm::InputTag>("InputLabel"));
 
   //start counters
   ndigis = 0;
   nwords = 0;
 
   // Products
   produces<edm::DetSetVector<PixelDigi>>();
   if (includeErrors) {
     produces<edm::DetSetVector<SiPixelRawDataError>>();
     produces<DetIdCollection>();
     produces<DetIdCollection>("UserErrorModules");
     produces<edmNew::DetSetVector<PixelFEDChannel>>();
   }
 
   // regions
   if (!config_.getParameter<edm::ParameterSet>("Regions").getParameterNames().empty()) {
     regions_ = new PixelUnpackingRegions(config_, consumesCollector());
   }
 
   // Timing
   bool timing = config_.getUntrackedParameter<bool>("Timing", false);
   if (timing) {
     theTimer.reset(new edm::CPUTimer);
     hCPU = new TH1D("hCPU", "hCPU", 100, 0., 0.050);
     hDigi = new TH1D("hDigi", "hDigi", 50, 0., 15000.);
   }
 
   // Control the usage of pilot-blade data, FED=40
   usePilotBlade = config_.getParameter<bool>("UsePilotBlade");
   if (usePilotBlade)
     edm::LogInfo("SiPixelRawToDigi") << " Use pilot blade data (FED 40)";
 
   // Control the usage of phase1
   usePhase1 = config_.getParameter<bool>("UsePhase1");
   if (usePhase1)
     edm::LogInfo("SiPixelRawToDigi") << " Using phase1";
 
   //CablingMap could have a label //Tav
   cablingMapLabel = config_.getParameter<std::string>("CablingMapLabel");
 }

SiPixelRawToDigi::~SiPixelRawToDigi ( )

override

dtor

Definition at line 96 of file SiPixelRawToDigi.cc.

References hCPU, hDigi, regions_, indexGen::rootFile, and theTimer.

                                     {
   edm::LogInfo("SiPixelRawToDigi") << " HERE ** SiPixelRawToDigi destructor!";
 
   if (regions_)
     delete regions_;
 
   if (theTimer) {
     TFile rootFile("analysis.root", "RECREATE", "my histograms");
     hCPU->Write();
     hDigi->Write();
   }
 }

Member Function Documentation

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

static

Definition at line 109 of file SiPixelRawToDigi.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), edm::ParameterSetDescription::addUntracked(), HLT_2018_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                   {
   edm::ParameterSetDescription desc;
   desc.add<bool>("IncludeErrors", true);
   desc.add<bool>("UseQualityInfo", false);
   {
     std::vector<int> temp1;
     temp1.reserve(1);
     temp1.push_back(29);
     desc.add<std::vector<int>>("ErrorList", temp1)
         ->setComment("## ErrorList: list of error codes used by tracking to invalidate modules");
   }
   {
     std::vector<int> temp1;
     temp1.reserve(1);
     temp1.push_back(40);
     desc.add<std::vector<int>>("UserErrorList", temp1)
         ->setComment("## UserErrorList: list of error codes used by Pixel experts for investigation");
   }
   desc.add<edm::InputTag>("InputLabel", edm::InputTag("siPixelRawData"));
   {
     edm::ParameterSetDescription psd0;
     psd0.addOptional<std::vector<edm::InputTag>>("inputs");
     psd0.addOptional<std::vector<double>>("deltaPhi");
     psd0.addOptional<std::vector<double>>("maxZ");
     psd0.addOptional<edm::InputTag>("beamSpot");
     desc.add<edm::ParameterSetDescription>("Regions", psd0)
         ->setComment("## Empty Regions PSet means complete unpacking");
   }
   desc.addUntracked<bool>("Timing", false);
   desc.add<bool>("UsePilotBlade", false)->setComment("##  Use pilot blades");
   desc.add<bool>("UsePhase1", false)->setComment("##  Use phase1");
   desc.add<std::string>("CablingMapLabel", "")->setComment("CablingMap label");  //Tav
   desc.addOptional<bool>("CheckPixelOrder");  // never used, kept for back-compatibility
   descriptions.add("siPixelRawToDigi", desc);
 }

void SiPixelRawToDigi::produce	(	edm::Event &	ev,
		const edm::EventSetup &	es
	)

override

get data, convert to digis attach againe to Event

Definition at line 148 of file SiPixelRawToDigi.cc.

References badPixelInfo_, cabling_, cablingMapLabel, SiPixelFedCablingMap::cablingTree(), edm::ESWatcher< T >::check(), universalConfigTemplate::collection, edm::DetSet< T >::data, debug, edm::MessageDrop::debugEnabled, DEFINE_FWK_MODULE, MessageLogger_cfi::errors, FEDRawDataCollection::FEDData(), l1tstage2_dqm_sourceclient-live_cfg::fedId, SiPixelFedCablingMap::fedIds(), fedIds, l1t_dqm_sourceclient-live_cfg::fedRawData, spr::find(), edm::EventSetup::get(), edm::Event::getByToken(), hCPU, hDigi, sipixelobjects::PixelROC::idInDetUnit(), includeErrors, edm::MessageDrop::instance(), MainPageGenerator::link, LogDebug, PixelUnpackingRegions::mayUnpackFED(), PixelUnpackingRegions::modulesToUnpack(), eostools::move(), PixelUnpackingRegions::nBarrelModules(), ndigis, PixelUnpackingRegions::nFEDs(), PixelUnpackingRegions::nForwardModules(), PixelUnpackingRegions::nModules(), sipixelobjects::PixelFEDLink::numberOfROCs(), nwords, edm::ESHandle< T >::product(), edm::Event::put(), qualityWatcher, recordWatcher, regions_, sipixelobjects::PixelFEDLink::roc(), PixelMapPlotter::roc, PixelFEDChannel::roc_first, PixelFEDChannel::roc_last, PixelUnpackingRegions::run(), PixelDataFormatter::setErrorStatus(), tFEDRawDataCollection, theTimer, tkerrorlist, usePhase1, usePilotBlade, useQuality, and usererrorlist.

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

                                                                     {
   const uint32_t dummydetid = 0xffffffff;
   debug = edm::MessageDrop::instance()->debugEnabled;
 
   // initialize cabling map or update if necessary
   if (recordWatcher.check(es)) {
     // cabling map, which maps online address (fed->link->ROC->local pixel) to offline (DetId->global pixel)
     edm::ESTransientHandle<SiPixelFedCablingMap> cablingMap;
     es.get<SiPixelFedCablingMapRcd>().get(cablingMapLabel, cablingMap);  //Tav
     fedIds = cablingMap->fedIds();
     cabling_ = cablingMap->cablingTree();
     LogDebug("map version:") << cabling_->version();
   }
   // initialize quality record or update if necessary
   if (qualityWatcher.check(es) && useQuality) {
     // quality info for dead pixel modules or ROCs
     edm::ESHandle<SiPixelQuality> qualityInfo;
     es.get<SiPixelQualityRcd>().get(qualityInfo);
     badPixelInfo_ = qualityInfo.product();
     if (!badPixelInfo_) {
       edm::LogError("SiPixelQualityNotPresent")
           << " Configured to use SiPixelQuality, but SiPixelQuality not present" << endl;
     }
   }
 
   edm::Handle<FEDRawDataCollection> buffers;
   ev.getByToken(tFEDRawDataCollection, buffers);
 
   // create product (digis & errors)
   auto collection = std::make_unique<edm::DetSetVector<PixelDigi>>();
   // collection->reserve(8*1024);
   auto errorcollection = std::make_unique<edm::DetSetVector<SiPixelRawDataError>>();
   auto tkerror_detidcollection = std::make_unique<DetIdCollection>();
   auto usererror_detidcollection = std::make_unique<DetIdCollection>();
   auto disabled_channelcollection = std::make_unique<edmNew::DetSetVector<PixelFEDChannel>>();
 
   PixelDataFormatter formatter(cabling_.get(), usePhase1);  // for phase 1 & 0
 
   formatter.setErrorStatus(includeErrors);
 
   if (useQuality)
     formatter.setQualityStatus(useQuality, badPixelInfo_);
 
   if (theTimer)
     theTimer->start();
   bool errorsInEvent = false;
   PixelDataFormatter::DetErrors nodeterrors;
 
   if (regions_) {
     regions_->run(ev, es);
     formatter.setModulesToUnpack(regions_->modulesToUnpack());
     LogDebug("SiPixelRawToDigi") << "region2unpack #feds: " << regions_->nFEDs();
     LogDebug("SiPixelRawToDigi") << "region2unpack #modules (BPIX,EPIX,total): " << regions_->nBarrelModules() << " "
                                  << regions_->nForwardModules() << " " << regions_->nModules();
   }
 
   for (auto aFed = fedIds.begin(); aFed != fedIds.end(); ++aFed) {
     int fedId = *aFed;
 
     if (!usePilotBlade && (fedId == 40))
       continue;  // skip pilot blade data
 
     if (regions_ && !regions_->mayUnpackFED(fedId))
       continue;
 
     if (debug)
       LogDebug("SiPixelRawToDigi") << " PRODUCE DIGI FOR FED: " << fedId << endl;
 
     PixelDataFormatter::Errors errors;
 
     //get event data for this fed
     const FEDRawData& fedRawData = buffers->FEDData(fedId);
 
     //convert data to digi and strip off errors
     formatter.interpretRawData(errorsInEvent, fedId, fedRawData, *collection, errors);
 
     //pack errors into collection
     if (includeErrors) {
       typedef PixelDataFormatter::Errors::iterator IE;
       for (IE is = errors.begin(); is != errors.end(); is++) {
         uint32_t errordetid = is->first;
         if (errordetid == dummydetid) {  // errors given dummy detId must be sorted by Fed
           nodeterrors.insert(nodeterrors.end(), errors[errordetid].begin(), errors[errordetid].end());
         } else {
           edm::DetSet<SiPixelRawDataError>& errorDetSet = errorcollection->find_or_insert(errordetid);
           errorDetSet.data.insert(errorDetSet.data.end(), is->second.begin(), is->second.end());
           // Fill detid of the detectors where there is error AND the error number is listed
           // in the configurable error list in the job option cfi.
           // Code needs to be here, because there can be a set of errors for each
           // entry in the for loop over PixelDataFormatter::Errors
 
           std::vector<PixelFEDChannel> disabledChannelsDetSet;
 
           for (auto const& aPixelError : errorDetSet) {
             // For the time being, we extend the error handling functionality with ErrorType 25
             // In the future, we should sort out how the usage of tkerrorlist can be generalized
             if (usePhase1 && aPixelError.getType() == 25) {
               assert(aPixelError.getFedId() == fedId);
               const sipixelobjects::PixelFEDCabling* fed = cabling_->fed(fedId);
               if (fed) {
                 cms_uint32_t linkId = formatter.linkId(aPixelError.getWord32());
                 const sipixelobjects::PixelFEDLink* link = fed->link(linkId);
                 if (link) {
                   // The "offline" 0..15 numbering is fixed by definition, also, the FrameConversion depends on it
                   // in contrast, the ROC-in-channel numbering is determined by hardware --> better to use the "offline" scheme
                   PixelFEDChannel ch = {fed->id(), linkId, 25, 0};
                   for (unsigned int iRoc = 1; iRoc <= link->numberOfROCs(); iRoc++) {
                     const sipixelobjects::PixelROC* roc = link->roc(iRoc);
                     if (roc->idInDetUnit() < ch.roc_first)
                       ch.roc_first = roc->idInDetUnit();
                     if (roc->idInDetUnit() > ch.roc_last)
                       ch.roc_last = roc->idInDetUnit();
                   }
                   disabledChannelsDetSet.push_back(ch);
                 }
               }
             } else {
               // fill list of detIds to be turned off by tracking
               if (!tkerrorlist.empty()) {
                 std::vector<int>::iterator it_find =
                     find(tkerrorlist.begin(), tkerrorlist.end(), aPixelError.getType());
                 if (it_find != tkerrorlist.end()) {
                   tkerror_detidcollection->push_back(errordetid);
                 }
               }
             }
 
             // fill list of detIds with errors to be studied
             if (!usererrorlist.empty()) {
               std::vector<int>::iterator it_find =
                   find(usererrorlist.begin(), usererrorlist.end(), aPixelError.getType());
               if (it_find != usererrorlist.end()) {
                 usererror_detidcollection->push_back(errordetid);
               }
             }
 
           }  // loop on DetSet of errors
 
           if (!disabledChannelsDetSet.empty()) {
             disabled_channelcollection->insert(
                 errordetid, disabledChannelsDetSet.data(), disabledChannelsDetSet.size());
           }
         }  // if error assigned to a real DetId
       }    // loop on errors in event for this FED
     }      // if errors to be included in the event
   }        // loop on FED data to be unpacked
 
   if (includeErrors) {
     edm::DetSet<SiPixelRawDataError>& errorDetSet = errorcollection->find_or_insert(dummydetid);
     errorDetSet.data = nodeterrors;
   }
   if (errorsInEvent)
     LogDebug("SiPixelRawToDigi") << "Error words were stored in this event";
 
   if (theTimer) {
     theTimer->stop();
     LogDebug("SiPixelRawToDigi") << "TIMING IS: (real)" << theTimer->realTime();
     ndigis += formatter.nDigis();
     nwords += formatter.nWords();
     LogDebug("SiPixelRawToDigi") << " (Words/Digis) this ev: " << formatter.nWords() << "/" << formatter.nDigis()
                                  << "--- all :" << nwords << "/" << ndigis;
     hCPU->Fill(theTimer->realTime());
     hDigi->Fill(formatter.nDigis());
   }
 
   ev.put(std::move(collection));
   if (includeErrors) {
     ev.put(std::move(errorcollection));
     ev.put(std::move(tkerror_detidcollection));
     ev.put(std::move(usererror_detidcollection), "UserErrorModules");
     ev.put(std::move(disabled_channelcollection));
   }
 }