Inheritance diagram for HLTTrackClusterRemoverNew:

Classes
struct	ParamBlock

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

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

	~HLTTrackClusterRemoverNew ()

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)

Private Types
typedef edm::ContainerMask< edmNew::DetSetVector< SiPixelCluster > >	PixelMaskContainer

typedef edm::ContainerMask< edmNew::DetSetVector< SiStripCluster > >	StripMaskContainer

Private Member Functions
template<typename T >
std::unique_ptr< edmNew::DetSetVector< T > >	cleanup (const edmNew::DetSetVector< T > &oldClusters, const std::vector< uint8_t > &isGood, reco::ClusterRemovalInfo::Indices &refs, const reco::ClusterRemovalInfo::Indices *oldRefs)

void	mergeOld (reco::ClusterRemovalInfo::Indices &refs, const reco::ClusterRemovalInfo::Indices &oldRefs)

void	process (const TrackingRecHit hit, float chi2, const TrackerGeometry tg)

void	process (const OmniClusterRef &cluRef, uint32_t subdet)

void	readPSet (const edm::ParameterSet &iConfig, const std::string &name, int id1=-1, int id2=-1, int id3=-1, int id4=-1, int id5=-1, int id6=-1)

Private Attributes
std::vector< bool >	collectedPixels_

std::vector< bool >	collectedRegStrips_

bool	doPixel_

bool	doPixelChargeCheck_

bool	doStrip_

bool	doStripChargeCheck_

bool	doTracks_

bool	makeProducts_

bool	mergeOld_

edm::EDGetTokenT< PixelMaskContainer >	oldPxlMaskToken_

edm::EDGetTokenT< StripMaskContainer >	oldStrMaskToken_

ParamBlock	pblocks_ [NumberOfParamBlocks]

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

std::vector< uint8_t >	pixels

edm::ProductID	pixelSourceProdID

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

std::vector< uint8_t >	strips

edm::ProductID	stripSourceProdID

edm::EDGetTokenT< std::vector< Trajectory > >	trajectories_

Static Private Attributes
static const unsigned int	NumberOfParamBlocks = 6

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)

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)

Detailed Description

Definition at line 39 of file HLTTrackClusterRemoverNew.cc.

Member Typedef Documentation

typedef edm::ContainerMask<edmNew::DetSetVector<SiPixelCluster> > HLTTrackClusterRemoverNew::PixelMaskContainer

private

Definition at line 68 of file HLTTrackClusterRemoverNew.cc.

typedef edm::ContainerMask<edmNew::DetSetVector<SiStripCluster> > HLTTrackClusterRemoverNew::StripMaskContainer

private

Definition at line 69 of file HLTTrackClusterRemoverNew.cc.

Constructor & Destructor Documentation

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

Definition at line 126 of file HLTTrackClusterRemoverNew.cc.

References doPixel_, doPixelChargeCheck_, doStrip_, doStripChargeCheck_, doTracks_, Exception, edm::ParameterSet::exists(), lumiContext::fill, edm::ParameterSet::getParameter(), mps_fire::i, mergeOld_, NumberOfParamBlocks, oldPxlMaskToken_, oldStrMaskToken_, pblocks_, pixelClusters_, readPSet(), stripClusters_, and trajectories_.

   : doTracks_(iConfig.exists("trajectories"))
   , doStrip_ (iConfig.existsAs<bool>("doStrip") ? iConfig.getParameter<bool>("doStrip") : true)
   , doPixel_ (iConfig.existsAs<bool>("doPixel") ? iConfig.getParameter<bool>("doPixel") : true)
   , mergeOld_(false)
   , makeProducts_(true)
   , doStripChargeCheck_(iConfig.existsAs<bool>("doStripChargeCheck") ? iConfig.getParameter<bool>("doStripChargeCheck") : false)
   , doPixelChargeCheck_(iConfig.existsAs<bool>("doPixelChargeCheck") ? iConfig.getParameter<bool>("doPixelChargeCheck") : false)
 
 {
 
   if (iConfig.exists("oldClusterRemovalInfo"))
     {
       oldPxlMaskToken_ = consumes<PixelMaskContainer>(iConfig.getParameter<InputTag>("oldClusterRemovalInfo"));
       oldStrMaskToken_ = consumes<StripMaskContainer>(iConfig.getParameter<InputTag>("oldClusterRemovalInfo"));
       if (not (iConfig.getParameter<InputTag>("oldClusterRemovalInfo")== edm::InputTag())) mergeOld_=true;
     }
 
   if ((doPixelChargeCheck_ && !doPixel_) || (doStripChargeCheck_ && !doStrip_))
     throw cms::Exception("Configuration Error") << "HLTTrackClusterRemoverNew: Charge check asked without cluster collection ";
   if (doPixelChargeCheck_)
     throw cms::Exception("Configuration Error") << "HLTTrackClusterRemoverNew: Pixel cluster charge check not yet implemented";
 
   fill(pblocks_, pblocks_+NumberOfParamBlocks, ParamBlock());
     readPSet(iConfig, "Common",-1);
     if (doPixel_) {
         readPSet(iConfig, "Pixel" , 0,1);
         readPSet(iConfig, "PXB" ,   0);
         readPSet(iConfig, "PXE" ,   1);
     }
     if (doStrip_) {
         readPSet(iConfig, "Strip" ,     2,3,4,5);
         readPSet(iConfig, "StripInner" ,2,3);
         readPSet(iConfig, "StripOuter" ,4,5);
         readPSet(iConfig, "TIB" ,       2);
         readPSet(iConfig, "TID" ,       3);
         readPSet(iConfig, "TOB" ,       4);
         readPSet(iConfig, "TEC" ,       5);
     }
 
     bool usingCharge = false;
     for (size_t i = 0; i < NumberOfParamBlocks; ++i) {
         if (!pblocks_[i].isSet_) throw cms::Exception("Configuration Error") << "HLTTrackClusterRemoverNew: Missing configuration for detector with subDetID = " << (i+1);
         if (pblocks_[i].usesCharge_ && !usingCharge) {
       throw cms::Exception("Configuration Error") << "HLTTrackClusterRemoverNew: Configuration for subDetID = " << (i+1) << " uses cluster charge, which is not enabled.";
         }
     }
     
     //    trajectories_ = consumes<vector<Trajectory> >(iConfig.getParameter<InputTag>("trajectories"));
     if (doTracks_) trajectories_ = consumes<vector<Trajectory> >                  (iConfig.getParameter<InputTag>("trajectories") );
     if (doPixel_) pixelClusters_ = consumes<edmNew::DetSetVector<SiPixelCluster> >(iConfig.getParameter<InputTag>("pixelClusters"));
     if (doStrip_) stripClusters_ = consumes<edmNew::DetSetVector<SiStripCluster> >     (iConfig.getParameter<InputTag>("stripClusters"));
     if (mergeOld_) {
       oldPxlMaskToken_ = consumes<PixelMaskContainer>(iConfig.getParameter<InputTag>("oldClusterRemovalInfo"));
       oldStrMaskToken_ = consumes<StripMaskContainer>(iConfig.getParameter<InputTag>("oldClusterRemovalInfo"));
     }
 
     //produces<edmNew::DetSetVector<SiPixelClusterRefNew> >();
     //produces<edmNew::DetSetVector<SiStripRecHit1D::ClusterRegionalRef> >();
     
     produces< edm::ContainerMask<edmNew::DetSetVector<SiPixelCluster> > >();
     produces< edm::ContainerMask<edmNew::DetSetVector<SiStripCluster> > >();
 
 }

HLTTrackClusterRemoverNew::~HLTTrackClusterRemoverNew ( )

Definition at line 192 of file HLTTrackClusterRemoverNew.cc.

193 {

194 }

Member Function Documentation

template<typename T >

std::unique_ptr< edmNew::DetSetVector< T > > HLTTrackClusterRemoverNew::cleanup	(	const edmNew::DetSetVector< T > &	oldClusters,
		const std::vector< uint8_t > &	isGood,
		reco::ClusterRemovalInfo::Indices &	refs,
		const reco::ClusterRemovalInfo::Indices *	oldRefs
	)

private

Definition at line 207 of file HLTTrackClusterRemoverNew.cc.

References edmNew::DetSetVector< T >::begin(), collectedRegStrips_, edmNew::DetSetVector< T >::data(), edmNew::DetSetVector< T >::dataSize(), edmNew::DetSetVector< T >::end(), OmniClusterRef::id(), diffTreeTool::index, OmniClusterRef::key(), mergeOld(), convertSQLitetoXML_cfg::output, process(), edmNew::DetSetVector< T >::size(), and stripSourceProdID.

                                                                                                    {
     typedef typename edmNew::DetSetVector<T>             DSV;
     typedef typename edmNew::DetSetVector<T>::FastFiller DSF;
     typedef typename edmNew::DetSet<T>                   DS;
     auto output = std::make_unique<DSV>();
     output->reserve(oldClusters.size(), oldClusters.dataSize());
 
     unsigned int countOld=0;
     unsigned int countNew=0;
 
     // cluster removal loop
     const T * firstOffset = & oldClusters.data().front();
     for (typename DSV::const_iterator itdet = oldClusters.begin(), enddet = oldClusters.end(); itdet != enddet; ++itdet) {
         DS oldDS = *itdet;
 
         if (oldDS.empty()) continue; // skip empty detsets
 
         uint32_t id = oldDS.detId();
         DSF outds(*output, id);
 
         for (typename DS::const_iterator it = oldDS.begin(), ed = oldDS.end(); it != ed; ++it) {
             uint32_t index = ((&*it) - firstOffset);
         countOld++;
             if (isGood[index]) { 
                 outds.push_back(*it);
         countNew++;
                 refs.push_back(index); 
                 //std::cout << "HLTTrackClusterRemoverNew::cleanup " << typeid(T).name() << " reference " << index << " to " << (refs.size() - 1) << std::endl;
             }
 
     }
         if (outds.empty()) outds.abort(); // not write in an empty DSV
     }
     //    double fraction = countNew  / (double) countOld;
     //    std::cout<<"fraction: "<<fraction<<std::endl;
     if (oldRefs != 0) mergeOld(refs, *oldRefs);
     return output;
 }

void HLTTrackClusterRemoverNew::mergeOld	(	reco::ClusterRemovalInfo::Indices &	refs,
		const reco::ClusterRemovalInfo::Indices &	oldRefs
	)

private

Definition at line 196 of file HLTTrackClusterRemoverNew.cc.

References mps_fire::i, and gen::n.

Referenced by cleanup().

 {
         for (size_t i = 0, n = refs.size(); i < n; ++i) {
             refs[i] = oldRefs[refs[i]];
        }
 }

void HLTTrackClusterRemoverNew::process	(	const TrackingRecHit *	hit,
		float	chi2,
		const TrackerGeometry *	tg
	)

inlineprivate

Definition at line 263 of file HLTTrackClusterRemoverNew.cc.

References SiPixelRecHit::cluster(), collectedPixels_, doPixel_, doStrip_, Exception, TrackingRecHit::geographicalId(), TrackerGeometry::geomDetSubDetector(), edm::Ref< C, T, F >::id(), GeomDetEnumerators::isTrackerPixel(), edm::Ref< C, T, F >::key(), HLTTrackClusterRemoverNew::ParamBlock::maxSize_, SiStripMatchedRecHit2D::monoClusterRef(), NumberOfParamBlocks, TrackerSingleRecHit::omniClusterRef(), ProjectedSiStripRecHit2D::originalHit(), pblocks_, pixelSourceProdID, DetId::rawId(), SiStripMatchedRecHit2D::stereoClusterRef(), and DetId::subdetId().

                                                                                                         {
     DetId detid = hit->geographicalId(); 
     uint32_t subdet = detid.subdetId();
 
 
     assert ((subdet > 0) && (subdet <= NumberOfParamBlocks));
 
     // chi2 cut
     if (chi2 > pblocks_[subdet-1].maxChi2_) return;
 
     if(GeomDetEnumerators::isTrackerPixel(tg->geomDetSubDetector(subdet))) {
       //      std::cout<<"process pxl hit"<<std::endl;
       if (!doPixel_) return;
       // this is a pixel, and i *know* it is
       const SiPixelRecHit *pixelHit = static_cast<const SiPixelRecHit *>(hit);
       
       SiPixelRecHit::ClusterRef cluster = pixelHit->cluster();
       if (cluster.id() != pixelSourceProdID) throw cms::Exception("Inconsistent Data") << 
     "HLTTrackClusterRemoverNew: pixel cluster ref from Product ID = " << cluster.id() << 
     " does not match with source cluster collection (ID = " << pixelSourceProdID << ")\n.";
       
       assert(cluster.id() == pixelSourceProdID);
       //DBG// cout << "HIT NEW PIXEL DETID = " << detid.rawId() << ", Cluster [ " << cluster.key().first << " / " <<  cluster.key().second << " ] " << endl;
       
       // if requested, cut on cluster size
       if (pblocks_[subdet-1].usesSize_ && (cluster->pixels().size() > pblocks_[subdet-1].maxSize_)) return;
       
       // mark as used
       //pixels[cluster.key()] = false;
       assert(collectedPixels_.size() > cluster.key());
       collectedPixels_[cluster.key()]=true;
     } else { // aka Strip
       if (!doStrip_) return;
       const type_info &hitType = typeid(*hit);
       if (hitType == typeid(SiStripRecHit2D)) {
     const SiStripRecHit2D *stripHit = static_cast<const SiStripRecHit2D *>(hit);
     //DBG//     cout << "Plain RecHit 2D: " << endl;
     process(stripHit->omniClusterRef(),subdet);
     //    int clusCharge=0;
     //    for ( auto cAmp : stripHit->omniClusterRef().stripCluster().amplitudes() ) clusCharge+=cAmp;
     //    std::cout << "[HLTTrackClusterRemoverNew::process (SiStripRecHit2D) chi2: " << chi2 << " [" << subdet << " --> charge: " << clusCharge << "]" << std::endl;
       } else if (hitType == typeid(SiStripRecHit1D)) {
     const SiStripRecHit1D *hit1D = static_cast<const SiStripRecHit1D *>(hit);
     process(hit1D->omniClusterRef(),subdet);
     //    int clusCharge=0;
     //    for ( auto cAmp : hit1D->omniClusterRef().stripCluster().amplitudes() ) clusCharge+=cAmp;
     //    std::cout << "[HLTTrackClusterRemoverNew::process (SiStripRecHit1D) chi2: " << chi2 << " [" << subdet << " --> charge: " << clusCharge << "]" << std::endl;
       } else if (hitType == typeid(SiStripMatchedRecHit2D)) {
     const SiStripMatchedRecHit2D *matchHit = static_cast<const SiStripMatchedRecHit2D *>(hit);
     //DBG//     cout << "Matched RecHit 2D: " << endl;
     process(matchHit->monoClusterRef(),  subdet);
     //      int clusCharge=0;
     //      for ( auto cAmp : matchHit->monoClusterRef().stripCluster().amplitudes() ) clusCharge+=cAmp;
     //      std::cout << "[HLTTrackClusterRemoverNew::process (SiStripMatchedRecHit2D:mono) chi2: " << chi2 << " [" << subdet << " --> charge: " << clusCharge << "]" << std::endl;
     
     process(matchHit->stereoClusterRef(),subdet);
     //      clusCharge=0;
     //      for ( auto cAmp : matchHit->stereoClusterRef().stripCluster().amplitudes() ) clusCharge+=cAmp;
     //      std::cout << "[HLTTrackClusterRemoverNew::process (SiStripMatchedRecHit2D:stereo) chi2: " << chi2 << " [" << subdet << " --> charge: " << clusCharge << "]" << std::endl;
     
       } else if (hitType == typeid(ProjectedSiStripRecHit2D)) {
     const ProjectedSiStripRecHit2D *projHit = static_cast<const ProjectedSiStripRecHit2D *>(hit);
     //DBG//     cout << "Projected RecHit 2D: " << endl;
     process(projHit->originalHit().omniClusterRef(),subdet);
     //      int clusCharge=0;
     //      for ( auto cAmp : projHit->originalHit().omniClusterRef().stripCluster().amplitudes() ) clusCharge+=cAmp;
     //      std::cout << "[HLTTrackClusterRemoverNew::process (ProjectedSiStripRecHit2D) chi2: " << chi2 << " [" << subdet << " --> charge: " << clusCharge << "]" << std::endl;
       } else throw cms::Exception("NOT IMPLEMENTED") << "Don't know how to handle " << hitType.name() << " on detid " << detid.rawId() << "\n";
     }
 }

void HLTTrackClusterRemoverNew::process	(	const OmniClusterRef &	cluRef,
		uint32_t	subdet
	)

inlineprivate

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

override

Definition at line 346 of file HLTTrackClusterRemoverNew.cc.

References fastPrimaryVertexProducer_cfi::clusters, collectedPixels_, collectedRegStrips_, edm::ContainerMask< T >::copyMaskTo(), KineDebug3::count(), DEFINE_FWK_MODULE, doPixel_, doStrip_, doStripChargeCheck_, edm::EventSetup::get(), edm::Event::getByToken(), mps_fire::i, edm::HandleBase::id(), TrackingRecHit::isValid(), LogDebug, Trajectory::measurements(), mergeOld_, oldPxlMaskToken_, oldStrMaskToken_, pblocks_, HiRegitMuonDetachedTripletStep_cff::pixelClusters, pixelClusters_, pixelSourceProdID, process(), edm::ESHandle< T >::product(), edm::Event::put(), edm::ContainerMask< T >::size(), HiRegitMuonDetachedTripletStep_cff::stripClusters, stripClusters_, stripSourceProdID, DetId::subdetId(), HiRegitMuonDetachedTripletStep_cff::trajectories, and trajectories_.

 {
     ProductID pixelOldProdID, stripOldProdID;
 
     edm::ESHandle<TrackerGeometry> tgh;
     iSetup.get<TrackerDigiGeometryRecord>().get(tgh);
 
     edm::Handle<edmNew::DetSetVector<SiPixelCluster> > pixelClusters;
     if (doPixel_) {
         iEvent.getByToken(pixelClusters_, pixelClusters);
         pixelSourceProdID = pixelClusters.id();
     }
 
     edm::Handle<edmNew::DetSetVector<SiStripCluster> > stripClusters;
     if (doStrip_) {
         iEvent.getByToken(stripClusters_, stripClusters);
         stripSourceProdID = stripClusters.id();
     }
 
     //Handle<TrajTrackAssociationCollection> trajectories; 
     edm::Handle<vector<Trajectory> > trajectories; 
     iEvent.getByToken(trajectories_, trajectories);
 
     if(mergeOld_) {
       edm::Handle<PixelMaskContainer> oldPxlMask;
       edm::Handle<StripMaskContainer> oldStrMask;
       iEvent.getByToken(oldPxlMaskToken_ ,oldPxlMask);
       iEvent.getByToken(oldStrMaskToken_ ,oldStrMask);
       LogDebug("TrackClusterRemover")<<"to merge in, "<<oldStrMask->size()<<" strp and "<<oldPxlMask->size()<<" pxl";
       oldStrMask->copyMaskTo(collectedRegStrips_);
       oldPxlMask->copyMaskTo(collectedPixels_);
       collectedRegStrips_.resize(stripClusters->dataSize(),false);
     }else {
       collectedRegStrips_.resize(stripClusters->dataSize(), false);
       collectedPixels_.resize(pixelClusters->dataSize(), false);
     } 
 
 
     //for (TrajTrackAssociationCollection::const_iterator it = trajectories->begin(), ed = trajectories->end(); it != ed; ++it)  {
     //    const Trajectory &tj = * it->key;
 
     for (std::vector<Trajectory>::const_iterator it = trajectories->begin(), ed = trajectories->end(); it != ed; ++it)  {
       const Trajectory &tj = * it;
       const std::vector<TrajectoryMeasurement> &tms = tj.measurements();
       
       std::vector<TrajectoryMeasurement>::const_iterator itm, endtm;
       for (itm = tms.begin(), endtm = tms.end(); itm != endtm; ++itm) {
     
     const TrackingRecHit *hit = itm->recHit()->hit();
     if (!hit->isValid()) continue; 
     //      std::cout<<"process hit"<<std::endl;
     process( hit, itm->estimate() , tgh.product());
       }
     }
     
     
     //    std::cout << " => collectedRegStrips_: " << collectedRegStrips_.size() << std::endl;
     //    std::cout << " total strip to skip (before charge check): "<<std::count(collectedRegStrips_.begin(),collectedRegStrips_.end(),true) << std::endl;
 
 
     // checks only cluster already found! creates regression 
     if (doStripChargeCheck_) {
       //      std::cout << "[HLTTrackClusterRemoverNew::produce] doStripChargeCheck_: " << (doStripChargeCheck_ ? "true" : "false") << " stripClusters: " << stripClusters->size() << std::endl;
       
       
       auto const & clusters = stripClusters->data();
       for (auto const & item : stripClusters->ids()) {
     
     if (!item.isValid()) continue;  // not umpacked
     
     DetId detid = item.id;
     uint32_t subdet = detid.subdetId();
     if (!pblocks_[subdet-1].cutOnStripCharge_) continue;
     
     //  std::cout << " i: " << i << " --> detid: " << detid << " --> subdet: " << subdet << std::endl;
     
     for (int i = item.offset; i<item.offset+int(item.size); ++i) {
       int clusCharge=0;
       for ( auto cAmp : clusters[i].amplitudes() ) clusCharge+=cAmp;
       
       //    if (clusCharge < pblocks_[subdet-1].minGoodStripCharge_) std::cout << " clusCharge: " << clusCharge << std::endl;
       if(clusCharge < pblocks_[subdet-1].minGoodStripCharge_) collectedRegStrips_[i] = true; // (|= does not work!)
     }
     
       }
     }
     
     //    std::cout << " => collectedRegStrips_: " << collectedRegStrips_.size() << std::endl;
     //    std::cout << " total strip to skip: "<<std::count(collectedRegStrips_.begin(),collectedRegStrips_.end(),true) << std::endl;
     LogDebug("TrackClusterRemover")<<"total strip to skip: "<<std::count(collectedRegStrips_.begin(),collectedRegStrips_.end(),true);
     // std::cout << "TrackClusterRemover" <<" total strip to skip: "<<std::count(collectedRegStrips_.begin(),collectedRegStrips_.end(),true)<<std::endl;
     iEvent.put(std::make_unique<StripMaskContainer>(edm::RefProd<edmNew::DetSetVector<SiStripCluster> >(stripClusters),collectedRegStrips_));
     
     LogDebug("TrackClusterRemover")<<"total pxl to skip: "<<std::count(collectedPixels_.begin(),collectedPixels_.end(),true);
     iEvent.put(std::make_unique<PixelMaskContainer>(edm::RefProd<edmNew::DetSetVector<SiPixelCluster> >(pixelClusters),collectedPixels_));
 
     collectedRegStrips_.clear();
     collectedPixels_.clear();
     
     
 }

void HLTTrackClusterRemoverNew::readPSet	(	const edm::ParameterSet &	iConfig,
		const std::string &	name,
		int	id1 = `-1`,
		int	id2 = `-1`,
		int	id3 = `-1`,
		int	id4 = `-1`,
		int	id5 = `-1`,
		int	id6 = `-1`
	)

private

Definition at line 108 of file HLTTrackClusterRemoverNew.cc.

References edm::ParameterSet::exists(), lumiContext::fill, edm::ParameterSet::getParameter(), NumberOfParamBlocks, and pblocks_.

Referenced by HLTTrackClusterRemoverNew().

 {
     if (iConfig.exists(name)) {
         ParamBlock pblock(iConfig.getParameter<ParameterSet>(name));
         if (id1 == -1) {
             fill(pblocks_, pblocks_+NumberOfParamBlocks, pblock);
         } else {
             pblocks_[id1] = pblock;
             if (id2 != -1) pblocks_[id2] = pblock;
             if (id3 != -1) pblocks_[id3] = pblock;
             if (id4 != -1) pblocks_[id4] = pblock;
             if (id5 != -1) pblocks_[id5] = pblock;
             if (id6 != -1) pblocks_[id6] = pblock;
         }
     }
 }