#include <MeasurementTrackerEventProducer.h>

Inheritance diagram for MeasurementTrackerEventProducer:

Public Member Functions
	MeasurementTrackerEventProducer (const edm::ParameterSet &iConfig)

	~MeasurementTrackerEventProducer ()

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

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

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 ()

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, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

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

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

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

virtual	~EDConsumerBase () noexcept(false)

Protected Member Functions
void	getInactiveStrips (const edm::Event &event, std::vector< uint32_t > &rawInactiveDetIds) const

void	updatePhase2OT (const edm::Event &, Phase2OTMeasurementDetSet &thePh2OTDets) const

void	updatePixels (const edm::Event &, PxMeasurementDetSet &thePxDets, std::vector< bool > &pixelClustersToSkip) const

void	updateStacks (const edm::Event &, Phase2OTMeasurementDetSet &theStDets) const

void	updateStrips (const edm::Event &, StMeasurementDetSet &theStDets, std::vector< bool > &stripClustersToSkip) const

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 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)

Protected Attributes
bool	isPhase2

std::string	measurementTrackerLabel_

const edm::ParameterSet &	pset_

bool	selfUpdateSkipClusters_

std::vector< edm::EDGetTokenT< DetIdCollection > >	theInactivePixelDetectorLabels

std::vector< edm::EDGetTokenT< DetIdCollection > >	theInactiveStripDetectorLabels

edm::EDGetTokenT< edmNew::DetSetVector< Phase2TrackerCluster1D > >	thePh2OTClusterLabel

edm::EDGetTokenT< edmNew::DetSetVector< SiPixelCluster > >	thePixelClusterLabel

edm::EDGetTokenT< edm::ContainerMask< edmNew::DetSetVector< SiPixelCluster > > >	thePixelClusterMask

edm::EDGetTokenT< edmNew::DetSetVector< SiStripCluster > >	theStripClusterLabel

edm::EDGetTokenT< edm::ContainerMask< edmNew::DetSetVector< SiStripCluster > > >	theStripClusterMask

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

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

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Detailed Description

Definition at line 14 of file MeasurementTrackerEventProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 10 of file MeasurementTrackerEventProducer.cc.

References edm::ParameterSet::exists(), edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), isPhase2, LogDebug, pset_, selfUpdateSkipClusters_, createPayload::skip, AlCaHLTBitMon_QueryRunRegistry::string, lumiQTWidget::t, theInactivePixelDetectorLabels, theInactiveStripDetectorLabels, thePh2OTClusterLabel, thePixelClusterLabel, thePixelClusterMask, theStripClusterLabel, and theStripClusterMask.

                                                                                                :
     measurementTrackerLabel_(iConfig.getParameter<std::string>("measurementTracker")),
     pset_(iConfig)
 {
     std::vector<edm::InputTag> inactivePixelDetectorTags(iConfig.getParameter<std::vector<edm::InputTag> >("inactivePixelDetectorLabels"));
     for (auto &t : inactivePixelDetectorTags) theInactivePixelDetectorLabels.push_back(consumes<DetIdCollection>(t));
 
     std::vector<edm::InputTag> inactiveStripDetectorTags(iConfig.getParameter<std::vector<edm::InputTag> >("inactiveStripDetectorLabels"));
     for (auto &t : inactiveStripDetectorTags) theInactiveStripDetectorLabels.push_back(consumes<DetIdCollection>(t));
 
     //the measurement tracking is set to skip clusters, the other option is set from outside
     selfUpdateSkipClusters_=iConfig.exists("skipClusters");
     if (selfUpdateSkipClusters_)
     {
         edm::InputTag skip=iConfig.getParameter<edm::InputTag>("skipClusters");
         if (skip==edm::InputTag("")) selfUpdateSkipClusters_=false;
     }
     LogDebug("MeasurementTracker")<<"skipping clusters: "<<selfUpdateSkipClusters_;
     isPhase2 = false;
 
     if (pset_.getParameter<std::string>("stripClusterProducer") != "") {
         theStripClusterLabel = consumes<edmNew::DetSetVector<SiStripCluster> >(edm::InputTag(pset_.getParameter<std::string>("stripClusterProducer")));
         if (selfUpdateSkipClusters_) theStripClusterMask = consumes<edm::ContainerMask<edmNew::DetSetVector<SiStripCluster>>>(iConfig.getParameter<edm::InputTag>("skipClusters"));
     }
     if (pset_.getParameter<std::string>("pixelClusterProducer") != "") {
         thePixelClusterLabel = consumes<edmNew::DetSetVector<SiPixelCluster> >(edm::InputTag(pset_.getParameter<std::string>("pixelClusterProducer")));
         if (selfUpdateSkipClusters_) thePixelClusterMask = consumes<edm::ContainerMask<edmNew::DetSetVector<SiPixelCluster>>>(iConfig.getParameter<edm::InputTag>("skipClusters"));
     }
     if (pset_.existsAs<std::string>("Phase2TrackerCluster1DProducer")) {
         thePh2OTClusterLabel = consumes<edmNew::DetSetVector<Phase2TrackerCluster1D> >(edm::InputTag(pset_.getParameter<std::string>("Phase2TrackerCluster1DProducer")));
         isPhase2 = true;
     }
 
     produces<MeasurementTrackerEvent>();
 }

MeasurementTrackerEventProducer::~MeasurementTrackerEventProducer ( )

inline

Definition at line 17 of file MeasurementTrackerEventProducer.h.

References edm::stream::EDProducerBase::produce().

17 {}

Member Function Documentation

void MeasurementTrackerEventProducer::getInactiveStrips	(	const edm::Event &	event,
		std::vector< uint32_t > &	rawInactiveDetIds
	)		const

protected

Definition at line 274 of file MeasurementTrackerEventProducer.cc.

References edm::EDCollection< T >::begin(), DEFINE_FWK_MODULE, edm::EDCollection< T >::end(), edm::Event::getByToken(), and theInactiveStripDetectorLabels.

Referenced by updateStrips().

 {
   if (!theInactiveStripDetectorLabels.empty()) {
     edm::Handle<DetIdCollection> detIds;
     for (const edm::EDGetTokenT<DetIdCollection> &tk : theInactiveStripDetectorLabels) {
         if (event.getByToken(tk, detIds)){
             rawInactiveDetIds.insert(rawInactiveDetIds.end(), detIds->begin(), detIds->end());
         }
     }
     if (!rawInactiveDetIds.empty()) std::sort(rawInactiveDetIds.begin(), rawInactiveDetIds.end());
   }
 
 }

void MeasurementTrackerEventProducer::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivatevirtual

Definition at line 47 of file MeasurementTrackerEventProducer.cc.

References edm::EventSetup::get(), MeasurementTrackerEventProducer_cfi::measurementTracker, measurementTrackerLabel_, eostools::move(), MeasurementTracker::phase2DetConditions(), MeasurementTracker::pixelDetConditions(), edm::Event::put(), MeasurementTracker::stripDetConditions(), updatePhase2OT(), updatePixels(), updateStacks(), and updateStrips().

 {
     edm::ESHandle<MeasurementTracker> measurementTracker;
     iSetup.get<CkfComponentsRecord>().get(measurementTrackerLabel_, measurementTracker);
 
     // create new data structures from templates
     auto stripData = std::make_unique<StMeasurementDetSet>(measurementTracker->stripDetConditions());
     auto pixelData=  std::make_unique<PxMeasurementDetSet>(measurementTracker->pixelDetConditions());
     auto phase2OTData = std::make_unique<Phase2OTMeasurementDetSet>(measurementTracker->phase2DetConditions());
     std::vector<bool> stripClustersToSkip;
     std::vector<bool> pixelClustersToSkip;
     std::vector<bool> phase2ClustersToSkip;
     // fill them
     updateStrips(iEvent, *stripData, stripClustersToSkip);
     updatePixels(iEvent, *pixelData, pixelClustersToSkip);
     updatePhase2OT(iEvent, *phase2OTData);
     updateStacks(iEvent, *phase2OTData);
 
     // put into MTE
     // put into event
     iEvent.put(std::move(
       std::make_unique<MeasurementTrackerEvent>(*measurementTracker, 
                                                 stripData.release(), pixelData.release(), phase2OTData.release(),
                                             stripClustersToSkip, pixelClustersToSkip, phase2ClustersToSkip)
     ));
 }

void MeasurementTrackerEventProducer::updatePhase2OT	(	const edm::Event &	event,
		Phase2OTMeasurementDetSet &	thePh2OTDets
	)		const

protected

Definition at line 235 of file MeasurementTrackerEventProducer.cc.

References edmNew::DetSetVector< T >::begin(), edmNew::DetSetVector< T >::end(), edm::Event::getByToken(), edm::ParameterSet::getParameter(), Phase2OTMeasurementDetSet::handle(), mps_fire::i, edmNew::DetSet< T >::id(), Phase2OTMeasurementDetSet::id(), Phase2OTMeasurementDetSet::isActive(), isPhase2, seedClusterRemoverPhase2_cfi::phase2OTClusters, edm::Handle< T >::product(), pset_, Phase2OTMeasurementDetSet::setActiveThisEvent(), Phase2OTMeasurementDetSet::size(), AlCaHLTBitMon_QueryRunRegistry::string, thePh2OTClusterLabel, and Phase2OTMeasurementDetSet::update().

Referenced by produce().

                                                                                                                        {
 
 
   // Phase2OT Clusters
   if ( isPhase2 ) {
 
     std::string phase2ClusterProducer = pset_.getParameter<std::string>("Phase2TrackerCluster1DProducer");
     if( phase2ClusterProducer.empty() ) { //clusters have not been produced
       thePh2OTDets.setActiveThisEvent(false);
     } else {
   
       edm::Handle<edmNew::DetSetVector<Phase2TrackerCluster1D> > & phase2OTClusters = thePh2OTDets.handle();
       if (event.getByToken(thePh2OTClusterLabel, phase2OTClusters)) {
     const edmNew::DetSetVector<Phase2TrackerCluster1D>* phase2OTCollection = phase2OTClusters.product();
   
     int i = 0, endDet = thePh2OTDets.size();
     for (edmNew::DetSetVector<Phase2TrackerCluster1D>::const_iterator it = phase2OTCollection->begin(), ed = phase2OTCollection->end(); it != ed; ++it) {
       
       edmNew::DetSet<Phase2TrackerCluster1D> set(*it);
       unsigned int id = set.id();
       while ( id != thePh2OTDets.id(i)) {
             ++i;
             if (endDet==i) throw "we have a problem!!!!";
       }
       // push cluster range in det
       if ( thePh2OTDets.isActive(i) ) {
             thePh2OTDets.update(i,set);
       }
     }
       } else {
     edm::LogWarning("MeasurementTrackerEventProducer") << "input Phase2TrackerCluster1D collection " << pset_.getParameter<std::string>("Phase2TrackerCluster1DProducer") << " is not valid";
       }
     }
 
   }
   return;
 }

void MeasurementTrackerEventProducer::updatePixels	(	const edm::Event &	event,
		PxMeasurementDetSet &	thePxDets,
		std::vector< bool > &	pixelClustersToSkip
	)		const

protected

Definition at line 75 of file MeasurementTrackerEventProducer.cc.

Referenced by produce().

 {
   // start by clearinng everything
   thePxDets.setEmpty();
 
   bool switchOffPixelsIfEmpty = pset_.getParameter<bool>("switchOffPixelsIfEmpty");
   std::vector<uint32_t> rawInactiveDetIds; 
   if (!theInactivePixelDetectorLabels.empty()) {
     edm::Handle<DetIdCollection> detIds;
     for (const edm::EDGetTokenT<DetIdCollection> &tk : theInactivePixelDetectorLabels) {
       if (event.getByToken(tk, detIds)){
         rawInactiveDetIds.insert(rawInactiveDetIds.end(), detIds->begin(), detIds->end());
       }else{
         static std::atomic<bool> iFailedAlready{false};
         bool expected = false;
         if (iFailedAlready.compare_exchange_strong(expected,true,std::memory_order_acq_rel)){
           edm::LogError("MissingProduct")<<"I fail to get the list of inactive pixel modules, because of 4.2/4.4 event content change.";
         }
       }
     }
     if (!rawInactiveDetIds.empty()) std::sort(rawInactiveDetIds.begin(), rawInactiveDetIds.end());
     // mark as inactive if in rawInactiveDetIds
     int i=0, endDet = thePxDets.size();
     unsigned int idp=0;
     for ( auto id : rawInactiveDetIds) {
         if (id==idp) continue; // skip multiple id
         idp=id;
         i=thePxDets.find(id,i);
         assert(i!=endDet && id == thePxDets.id(i));
         thePxDets.setActiveThisEvent(i,false);
     }
   }
 
   // Pixel Clusters
   std::string pixelClusterProducer = pset_.getParameter<std::string>("pixelClusterProducer");
   if( pixelClusterProducer.empty() ) { //clusters have not been produced
     if (switchOffPixelsIfEmpty) {
       thePxDets.setActiveThisEvent(false);
     }
   }else{  
 
     edm::Handle<edmNew::DetSetVector<SiPixelCluster> > & pixelClusters = thePxDets.handle();
     if(event.getByToken(thePixelClusterLabel, pixelClusters)) {
     
       const  edmNew::DetSetVector<SiPixelCluster>* pixelCollection = pixelClusters.product();
       
    
       if (switchOffPixelsIfEmpty && pixelCollection->empty()) {
     thePxDets.setActiveThisEvent(false);
       } else { 
     
     //std::cout <<"updatePixels "<<pixelCollection->dataSize()<<std::endl;
     pixelClustersToSkip.resize(pixelCollection->dataSize());
     std::fill(pixelClustersToSkip.begin(),pixelClustersToSkip.end(),false);
     
     if(selfUpdateSkipClusters_) {
           edm::Handle<edm::ContainerMask<edmNew::DetSetVector<SiPixelCluster> > > pixelClusterMask;
       //and get the collection of pixel ref to skip
       event.getByToken(thePixelClusterMask,pixelClusterMask);
       LogDebug("MeasurementTracker")<<"getting pxl refs to skip";
       if (pixelClusterMask.failedToGet())edm::LogError("MeasurementTracker")<<"not getting the pixel clusters to skip";
       if (pixelClusterMask->refProd().id()!=pixelClusters.id()){
         edm::LogError("ProductIdMismatch")<<"The pixel masking does not point to the proper collection of clusters: "<<pixelClusterMask->refProd().id()<<"!="<<pixelClusters.id();
       }
       pixelClusterMask->copyMaskTo(pixelClustersToSkip);
     }
     
     
     // FIXME: should check if lower_bound is better
     int i = 0, endDet = thePxDets.size();
     for (edmNew::DetSetVector<SiPixelCluster>::const_iterator it = pixelCollection->begin(), ed = pixelCollection->end(); it != ed; ++it) {
       edmNew::DetSet<SiPixelCluster> set(*it);
       unsigned int id = set.id();
       while ( id != thePxDets.id(i)) { 
         ++i;
         if (endDet==i) throw "we have a problem!!!!";
       }
       // push cluster range in det
       if ( thePxDets.isActive(i) ) {
         thePxDets.update(i,set);         
       }
     }
       }
     } else {
       edm::LogWarning("MeasurementTrackerEventProducer") << "input pixel clusters collection " << pset_.getParameter<std::string>("pixelClusterProducer") << " is not valid";
     }
   }
 }

void MeasurementTrackerEventProducer::updateStacks	(	const edm::Event &	,
		Phase2OTMeasurementDetSet &	theStDets
	)		const

inlineprotected

Definition at line 26 of file MeasurementTrackerEventProducer.h.

Referenced by produce().

26 {};

void MeasurementTrackerEventProducer::updateStrips	(	const edm::Event &	event,
		StMeasurementDetSet &	theStDets,
		std::vector< bool > &	stripClustersToSkip
	)		const

protected

Definition at line 165 of file MeasurementTrackerEventProducer.cc.

References edm::HandleBase::failedToGet(), StMeasurementDetSet::find(), edm::Event::getByToken(), getInactiveStrips(), edm::ParameterSet::getParameter(), StMeasurementDetSet::handle(), mps_fire::i, hcalTTPDigis_cfi::id, edm::HandleBase::id(), StMeasurementDetSet::id(), StMeasurementDetSet::isActive(), LogDebug, edm::Handle< T >::product(), pset_, selfUpdateSkipClusters_, StMeasurementDetSet::setActiveThisEvent(), StMeasurementDetSet::setEmpty(), StMeasurementDetSet::size(), AlCaHLTBitMon_QueryRunRegistry::string, nuclearRemainingHits_cff::stripClusterProducer, theStripClusterLabel, theStripClusterMask, mitigatedMETSequence_cff::U, and StMeasurementDetSet::update().

Referenced by produce().

 {
   typedef edmNew::DetSet<SiStripCluster>   StripDetSet;
 
   std::vector<uint32_t> rawInactiveDetIds;
   getInactiveStrips(event,rawInactiveDetIds);
 
   // Strip Clusters
   std::string stripClusterProducer = pset_.getParameter<std::string>("stripClusterProducer");
   //first clear all of them
   theStDets.setEmpty();
 
 
   if( !stripClusterProducer.compare("") )  return;  //clusters have not been produced
 
   const int endDet = theStDets.size();
  
 
   // mark as inactive if in rawInactiveDetIds
   int i=0;
   unsigned int idp=0;
   for ( auto id : rawInactiveDetIds) {
     if (id==idp) continue; // skip multiple id
     idp=id;
     i=theStDets.find(id,i);
     assert(i!=endDet && id == theStDets.id(i));
     theStDets.setActiveThisEvent(i,false);
   }
 
   //=========  actually load cluster =============
   {
     edm::Handle<edmNew::DetSetVector<SiStripCluster> > clusterHandle;
     if (event.getByToken(theStripClusterLabel, clusterHandle)) {
       const edmNew::DetSetVector<SiStripCluster>* clusterCollection = clusterHandle.product();
     
     
       if (selfUpdateSkipClusters_){
     edm::Handle<edm::ContainerMask<edmNew::DetSetVector<SiStripCluster> > > stripClusterMask;
     //and get the collection of pixel ref to skip
     LogDebug("MeasurementTracker")<<"getting strp refs to skip";
     event.getByToken(theStripClusterMask,stripClusterMask);
     if (stripClusterMask.failedToGet())  edm::LogError("MeasurementTracker")<<"not getting the strip clusters to skip";
     if (stripClusterMask->refProd().id()!=clusterHandle.id()){
       edm::LogError("ProductIdMismatch")<<"The strip masking does not point to the proper collection of clusters: "<<stripClusterMask->refProd().id()<<"!="<<clusterHandle.id();
     }
     stripClusterMask->copyMaskTo(stripClustersToSkip);
       }
     
       theStDets.handle() = clusterHandle;
       int i=0;
       // cluster and det and in order (both) and unique so let's use set intersection
       for ( auto j = 0U; j< (*clusterCollection).size(); ++j) {
     unsigned int id = (*clusterCollection).id(j);
     while ( id != theStDets.id(i)) { // eventually change to lower_bound
       ++i;
       if (endDet==i) throw "we have a problem in strips!!!!";
     }
       
     // push cluster range in det
     if ( theStDets.isActive(i) )
       theStDets.update(i,j);
       }
     } else {
       edm::LogWarning("MeasurementTrackerEventProducer") << "input strip cluster collection " << pset_.getParameter<std::string>("stripClusterProducer") << " is not valid";
     }
   }
 }