#include <MeasurementTrackerEventProducer.h>

Inheritance diagram for MeasurementTrackerEventProducer:

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

	~MeasurementTrackerEventProducer () override

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)

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 TrackerGeometry &trackerGeom, const edm::EventSetup &iSetup) const

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

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

Protected Attributes
bool	isPhase2

std::string	measurementTrackerLabel_

std::string	pixelCablingMapLabel_

bool	selfUpdateSkipClusters_

bool	switchOffPixelsIfEmpty_

std::vector< edm::EDGetTokenT< PixelFEDChannelCollection > >	theBadPixelFEDChannelsLabels

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

Detailed Description

Definition at line 16 of file MeasurementTrackerEventProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 17 of file MeasurementTrackerEventProducer.cc.

References edm::ParameterSet::getParameter(), HLT_2018_cff::InputTag, isPhase2, LogDebug, pixelCablingMapLabel_, selfUpdateSkipClusters_, optionsL1T::skip, AlCaHLTBitMon_QueryRunRegistry::string, OrderedSet::t, theBadPixelFEDChannelsLabels, theInactivePixelDetectorLabels, theInactiveStripDetectorLabels, thePh2OTClusterLabel, thePixelClusterLabel, thePixelClusterMask, theStripClusterLabel, and theStripClusterMask.

     : measurementTrackerLabel_(iConfig.getParameter<std::string>("measurementTracker")),
       switchOffPixelsIfEmpty_(iConfig.getParameter<bool>("switchOffPixelsIfEmpty")) {
   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> badPixelFEDChannelCollectionTags =
       iConfig.getParameter<std::vector<edm::InputTag>>("badPixelFEDChannelCollectionLabels");
   if (!badPixelFEDChannelCollectionTags.empty()) {
     for (auto& t : badPixelFEDChannelCollectionTags)
       theBadPixelFEDChannelsLabels.push_back(consumes<PixelFEDChannelCollection>(t));
     pixelCablingMapLabel_ = iConfig.getParameter<std::string>("pixelCablingMapLabel");
   }
 
   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
   edm::InputTag skip = iConfig.getParameter<edm::InputTag>("skipClusters");
   selfUpdateSkipClusters_ = !(skip == edm::InputTag(""));
   LogDebug("MeasurementTracker") << "skipping clusters: " << selfUpdateSkipClusters_;
   isPhase2 = false;
 
   if (!iConfig.getParameter<std::string>("stripClusterProducer").empty()) {
     theStripClusterLabel = consumes<edmNew::DetSetVector<SiStripCluster>>(
         edm::InputTag(iConfig.getParameter<std::string>("stripClusterProducer")));
     if (selfUpdateSkipClusters_)
       theStripClusterMask = consumes<edm::ContainerMask<edmNew::DetSetVector<SiStripCluster>>>(
           iConfig.getParameter<edm::InputTag>("skipClusters"));
   }
   if (!iConfig.getParameter<std::string>("pixelClusterProducer").empty()) {
     thePixelClusterLabel = consumes<edmNew::DetSetVector<SiPixelCluster>>(
         edm::InputTag(iConfig.getParameter<std::string>("pixelClusterProducer")));
     if (selfUpdateSkipClusters_)
       thePixelClusterMask = consumes<edm::ContainerMask<edmNew::DetSetVector<SiPixelCluster>>>(
           iConfig.getParameter<edm::InputTag>("skipClusters"));
   }
   if (!iConfig.getParameter<std::string>("Phase2TrackerCluster1DProducer").empty()) {
     thePh2OTClusterLabel = consumes<edmNew::DetSetVector<Phase2TrackerCluster1D>>(
         edm::InputTag(iConfig.getParameter<std::string>("Phase2TrackerCluster1DProducer")));
     isPhase2 = true;
   }
 
   produces<MeasurementTrackerEvent>();
 }

MeasurementTrackerEventProducer::~MeasurementTrackerEventProducer ( )

inlineoverride

Definition at line 19 of file MeasurementTrackerEventProducer.h.

References fillDescriptions().

19 {}

Member Function Documentation

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

static

Definition at line 67 of file MeasurementTrackerEventProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), HLT_2018_cff::InputTag, edm::ParameterDescriptionNode::setComment(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                  {
   edm::ParameterSetDescription desc;
 
   desc.add<std::string>("measurementTracker", "");
   desc.add<edm::InputTag>("skipClusters", edm::InputTag());
   desc.add<std::string>("pixelClusterProducer", "siPixelClusters");
   desc.add<std::string>("stripClusterProducer", "siStripClusters");
   desc.add<std::string>("Phase2TrackerCluster1DProducer", "");
 
   desc.add<std::vector<edm::InputTag>>("inactivePixelDetectorLabels",
                                        std::vector<edm::InputTag>{{edm::InputTag("siPixelDigis")}})
       ->setComment("One or more DetIdCollections of modules to mask on the fly for a given event");
   desc.add<std::vector<edm::InputTag>>("badPixelFEDChannelCollectionLabels", std::vector<edm::InputTag>())
       ->setComment("One or more PixelFEDChannelCollections of modules+ROCs to mask on the fly for a given event");
   desc.add<std::string>("pixelCablingMapLabel", "");
 
   desc.add<std::vector<edm::InputTag>>("inactiveStripDetectorLabels",
                                        std::vector<edm::InputTag>{{edm::InputTag("siStripDigis")}})
       ->setComment("One or more DetIdCollections of modules to mask on the fly for a given event");
 
   desc.add<bool>("switchOffPixelsIfEmpty", true)->setComment("let's keep it like this, for cosmics");
 
   descriptions.add("measurementTrackerEventDefault", desc);
 }

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

protected

Definition at line 390 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
	)

overrideprivate

Definition at line 92 of file MeasurementTrackerEventProducer.cc.

References MeasurementTracker::geomTracker(), edm::EventSetup::get(), HLTSiStripMonitoring_cff::measurementTracker, measurementTrackerLabel_, 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,
                dynamic_cast<const TrackerGeometry&>(*(measurementTracker->geomTracker())),
                iSetup);
   updatePhase2OT(iEvent, *phase2OTData);
   updateStacks(iEvent, *phase2OTData);
 
   // put into MTE
   // put into event
   iEvent.put(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 351 of file MeasurementTrackerEventProducer.cc.

References edmNew::DetSetVector< T >::begin(), edmNew::DetSetVector< T >::end(), edm::Event::getByToken(), Phase2OTMeasurementDetSet::handle(), mps_fire::i, edmNew::DetSet< T >::id(), Phase2OTMeasurementDetSet::id(), Phase2OTMeasurementDetSet::isActive(), isPhase2, edm::EDGetTokenT< T >::isUninitialized(), SummaryClient_cfi::labels, edm::ProductLabels::module, seedClusterRemoverPhase2_cfi::phase2OTClusters, edm::Handle< T >::product(), Phase2OTMeasurementDetSet::setActiveThisEvent(), Phase2OTMeasurementDetSet::size(), thePh2OTClusterLabel, and Phase2OTMeasurementDetSet::update().

Referenced by produce().

                                                                                                     {
   // Phase2OT Clusters
   if (isPhase2) {
     if (thePh2OTClusterLabel.isUninitialized()) {  //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::EDConsumerBase::Labels labels;
         labelsForToken(thePh2OTClusterLabel, labels);
         edm::LogWarning("MeasurementTrackerEventProducer")
             << "input Phase2TrackerCluster1D collection " << labels.module << " is not valid";
       }
     }
   }
   return;
 }

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

protected

Definition at line 124 of file MeasurementTrackerEventProducer.cc.

Referenced by produce().

                                                                                       {
   // start by clearinng everything
   thePxDets.setEmpty();
 
   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);
     }
   }
 
   if (!theBadPixelFEDChannelsLabels.empty()) {
     edm::ESHandle<SiPixelFedCablingMap> cablingMap;
     iSetup.get<SiPixelFedCablingMapRcd>().get(pixelCablingMapLabel_, cablingMap);
 
     edm::Handle<PixelFEDChannelCollection> pixelFEDChannelCollectionHandle;
     for (const edm::EDGetTokenT<PixelFEDChannelCollection>& tk : theBadPixelFEDChannelsLabels) {
       if (!event.getByToken(tk, pixelFEDChannelCollectionHandle))
         continue;
       int i = 0;
       for (const auto& disabledChannels : *pixelFEDChannelCollectionHandle) {
         PxMeasurementDetSet::BadFEDChannelPositions positions;
         for (const auto& ch : disabledChannels) {
           const sipixelobjects::PixelROC *roc_first = nullptr, *roc_last = nullptr;
           sipixelobjects::CablingPathToDetUnit path = {ch.fed, ch.link, 0};
           // PixelFEDChannelCollection addresses the ROCs by their 'idInDetUnit' (from 0 to 15), ROCs also know their on 'idInDetUnit',
           // however the cabling map uses a numbering [1,numberOfROCs], see sipixelobjects::PixelFEDLink::roc(unsigned int id), not necessarily sorted in the same direction.
           // PixelFEDChannelCollection MUST be filled such that ch.roc_first (ch.roc_last) correspond to the lowest (highest) 'idInDetUnit' in the channel
           for (path.roc = 1; path.roc <= (ch.roc_last - ch.roc_first) + 1; path.roc++) {
             const sipixelobjects::PixelROC* roc = cablingMap->findItem(path);
             if (roc == nullptr)
               continue;
             assert(roc->rawId() == disabledChannels.detId());
             if (roc->idInDetUnit() == ch.roc_first)
               roc_first = roc;
             if (roc->idInDetUnit() == ch.roc_last)
               roc_last = roc;
           }
           if (roc_first == nullptr || roc_last == nullptr) {
             edm::LogError("PixelFEDChannelCollection")
                 << "Do not find either roc_first or roc_last in the cabling map.";
             continue;
           }
           const PixelGeomDetUnit* theGeomDet =
               dynamic_cast<const PixelGeomDetUnit*>(trackerGeom.idToDet(roc_first->rawId()));
           PixelTopology const* topology = &(theGeomDet->specificTopology());
           sipixelobjects::LocalPixel::RocRowCol local = {
               topology->rowsperroc() / 2, topology->colsperroc() / 2};  //corresponding to center of ROC row, col
           sipixelobjects::GlobalPixel global = roc_first->toGlobal(sipixelobjects::LocalPixel(local));
           LocalPoint lp1 = topology->localPosition(MeasurementPoint(global.row, global.col));
           global = roc_last->toGlobal(sipixelobjects::LocalPixel(local));
           LocalPoint lp2 = topology->localPosition(MeasurementPoint(global.row, global.col));
           LocalPoint ll(std::min(lp1.x(), lp2.x()), std::min(lp1.y(), lp2.y()), std::min(lp1.z(), lp2.z()));
           LocalPoint ur(std::max(lp1.x(), lp2.x()), std::max(lp1.y(), lp2.y()), std::max(lp1.z(), lp2.z()));
           positions.push_back(std::make_pair(ll, ur));
         }  // loop on channels
         if (!positions.empty()) {
           i = thePxDets.find(disabledChannels.detId(), i);
           assert(i != thePxDets.size() && thePxDets.id(i) == disabledChannels.detId());
           thePxDets.addBadFEDChannelPositions(i, positions);
         }
       }  // loop on DetId-s
     }    // loop on labels
   }      // if collection labels are populated
 
   // Pixel Clusters
   if (thePixelClusterLabel.isUninitialized()) {  //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::EDConsumerBase::Labels labels;
       labelsForToken(thePixelClusterLabel, labels);
       edm::LogWarning("MeasurementTrackerEventProducer")
           << "input pixel clusters collection " << labels.module << " is not valid";
     }
   }
 }

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

inlineprotected

Definition at line 35 of file MeasurementTrackerEventProducer.h.

Referenced by produce().

35 {};

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

protected

Definition at line 276 of file MeasurementTrackerEventProducer.cc.

References edm::HandleBase::failedToGet(), StMeasurementDetSet::find(), edm::Event::getByToken(), getInactiveStrips(), StMeasurementDetSet::handle(), mps_fire::i, triggerObjects_cff::id, edm::HandleBase::id(), StMeasurementDetSet::id(), StMeasurementDetSet::isActive(), edm::EDGetTokenT< T >::isUninitialized(), dqmiolumiharvest::j, SummaryClient_cfi::labels, LogDebug, edm::ProductLabels::module, edm::Handle< T >::product(), selfUpdateSkipClusters_, StMeasurementDetSet::setActiveThisEvent(), StMeasurementDetSet::setEmpty(), StMeasurementDetSet::size(), 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
   //first clear all of them
   theStDets.setEmpty();
 
   if (theStripClusterLabel.isUninitialized())
     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::EDConsumerBase::Labels labels;
       labelsForToken(theStripClusterLabel, labels);
       edm::LogWarning("MeasurementTrackerEventProducer")
           << "input strip cluster collection " << labels.module << " is not valid";
     }
   }
 }