#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	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () 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::exists(), edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNames(), edm::ParameterSet::getUntrackedParameter(), hCPU, hDigi, includeErrors, ndigis, nwords, regions_, AlCaHLTBitMon_QueryRunRegistry::string, tFEDRawDataCollection, theTimer, 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");
   if (config_.exists("ErrorList")) {
     tkerrorlist = config_.getParameter<std::vector<int> > ("ErrorList");
   }
   if (config_.exists("UserErrorList")) {
     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_.exists("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 = false; 
   if (config_.exists("UsePilotBlade")) {
     usePilotBlade = config_.getParameter<bool> ("UsePilotBlade");
     if(usePilotBlade) edm::LogInfo("SiPixelRawToDigi")  << " Use pilot blade data (FED 40)";
   }
 
   // Control the usage of phase1
   usePhase1 = false;
   if (config_.exists("UsePhase1")) {
     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 111 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 125 of file SiPixelRawToDigi.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), edm::ParameterSetDescription::addUntracked(), 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 162 of file SiPixelRawToDigi.cc.

References badPixelInfo_, cabling_, cablingMapLabel, SiPixelFedCablingMap::cablingTree(), edm::ESWatcher< T >::check(), universalConfigTemplate::collection, edm::DetSet< T >::data, debug, edm::MessageDrop::debugEnabled, benchmark_cfg::errors, FEDRawDataCollection::FEDData(), l1t::stage2::layer2::fedId, SiPixelFedCablingMap::fedIds(), fedIds, spr::find(), edm::EventSetup::get(), edm::Event::getByToken(), hCPU, hDigi, sipixelobjects::PixelROC::idInDetUnit(), includeErrors, edm::MessageDrop::instance(), 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(), 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()); // phase 0 only
   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 (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());
   }
 
   //send digis and errors back to framework 
   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));
   }
 }