Inheritance diagram for HITrackClusterRemover:

Classes
struct	ParamBlock

Public Member Functions
template<typename T >
auto_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)

	HITrackClusterRemover (const edm::ParameterSet &iConfig)

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

	~HITrackClusterRemover ()

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)

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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

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

Private Member Functions
template<typename T >
std::auto_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, SiStripDetId &detid, bool fromTrack)

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)

float	sensorThickness (const SiStripDetId &detid) const

Private Attributes
bool	clusterWasteSolution_

std::vector< bool >	collectedPixels_

std::vector< bool >	collectedStrips_

bool	doPixel_

bool	doPixelChargeCheck_

bool	doStrip_

bool	doStripChargeCheck_

bool	doTracks_

bool	filterTracks_

bool	mergeOld_

int	minNumberOfLayersWithMeasBeforeFiltering_

edm::EDGetTokenT < PixelMaskContainer >	oldPxlMaskToken_

edm::EDGetTokenT < reco::ClusterRemovalInfo >	oldRemovalInfo_

edm::EDGetTokenT < StripMaskContainer >	oldStrMaskToken_

std::vector< edm::EDGetTokenT < edm::ValueMap< int > > >	overrideTrkQuals_

ParamBlock	pblocks_ [NumberOfParamBlocks]

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

std::string	pixelRecHits_

std::vector< uint8_t >	pixels

edm::ProductID	pixelSourceProdID

edm::EDGetTokenT < SiStripRecHit2DCollection >	rphiRecHitToken_

edm::EDGetTokenT < SiStripRecHit2DCollection >	stereoRecHitToken_

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

std::string	stripRecHits_

std::vector< uint8_t >	strips

edm::ProductID	stripSourceProdID

reco::TrackBase::TrackQuality	trackQuality_

edm::EDGetTokenT < TrajTrackAssociationCollection >	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 43 of file HITrackClusterRemover.cc.

Member Typedef Documentation

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

private

Definition at line 71 of file HITrackClusterRemover.cc.

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

private

Definition at line 72 of file HITrackClusterRemover.cc.

Constructor & Destructor Documentation

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

Definition at line 138 of file HITrackClusterRemover.cc.

References clusterWasteSolution_, edm::EDConsumerBase::consumes(), doPixel_, doPixelChargeCheck_, doStrip_, doStripChargeCheck_, doTracks_, Exception, edm::ParameterSet::exists(), edm::ParameterSet::existsAs(), lumiContext::fill, filterTracks_, edm::ParameterSet::getParameter(), i, HLT_FULL_cff::InputTag, diffTwoXMLs::label, mergeOld_, minNumberOfLayersWithMeasBeforeFiltering_, NumberOfParamBlocks, oldPxlMaskToken_, oldRemovalInfo_, oldStrMaskToken_, overrideTrkQuals_, pblocks_, pixelClusters_, reco::TrackBase::qualityByName(), readPSet(), rphiRecHitToken_, stereoRecHitToken_, AlCaHLTBitMon_QueryRunRegistry::string, stripClusters_, stripRecHits_, trackQuality_, trajectories_, and reco::TrackBase::undefQuality.

                                                                        :
     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_(iConfig.exists("oldClusterRemovalInfo")),
     clusterWasteSolution_(true),
     doStripChargeCheck_(iConfig.existsAs<bool>("doStripChargeCheck") ? iConfig.getParameter<bool>("doStripChargeCheck") : false),
     doPixelChargeCheck_(iConfig.existsAs<bool>("doPixelChargeCheck") ? iConfig.getParameter<bool>("doPixelChargeCheck") : false),
     stripRecHits_(doStripChargeCheck_ ? iConfig.getParameter<std::string>("stripRecHits") : std::string("siStripMatchedRecHits")),
     pixelRecHits_(doPixelChargeCheck_ ? iConfig.getParameter<std::string>("pixelRecHits") : std::string("siPixelRecHits"))
 {
   mergeOld_ = mergeOld_ && iConfig.getParameter<InputTag>("oldClusterRemovalInfo").label()!="";
   if (iConfig.exists("overrideTrkQuals"))
     overrideTrkQuals_.push_back(consumes<edm::ValueMap<int> >(iConfig.getParameter<InputTag>("overrideTrkQuals")));
   if (iConfig.exists("clusterLessSolution"))
     clusterWasteSolution_=!iConfig.getParameter<bool>("clusterLessSolution");
   if ((doPixelChargeCheck_ && !doPixel_) || (doStripChargeCheck_ && !doStrip_))
       throw cms::Exception("Configuration Error") << "HITrackClusterRemover: Charge check asked without cluster collection ";
   if (doPixelChargeCheck_)
       throw cms::Exception("Configuration Error") << "HITrackClusterRemover: Pixel cluster charge check not yet implemented";
 
   if (doPixel_ && clusterWasteSolution_) produces< edmNew::DetSetVector<SiPixelCluster> >();
   if (doStrip_ && clusterWasteSolution_) produces< edmNew::DetSetVector<SiStripCluster> >();
   if (clusterWasteSolution_) produces< ClusterRemovalInfo >();
 
     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") << "HITrackClusterRemover: Missing configuration for detector with subDetID = " << (i+1);
         if (pblocks_[i].usesCharge_ && !usingCharge) {
             throw cms::Exception("Configuration Error") << "HITrackClusterRemover: Configuration for subDetID = " << (i+1) << " uses cluster charge, which is not enabled.";
         }
     }
 
     if (!clusterWasteSolution_){
       produces<edm::ContainerMask<edmNew::DetSetVector<SiPixelCluster> > >();
       produces<edm::ContainerMask<edmNew::DetSetVector<SiStripCluster> > >();
     }
     trackQuality_=reco::TrackBase::undefQuality;
     filterTracks_=false;
     if (iConfig.exists("TrackQuality")){
       filterTracks_=true;
       trackQuality_=reco::TrackBase::qualityByName(iConfig.getParameter<std::string>("TrackQuality"));
       minNumberOfLayersWithMeasBeforeFiltering_ = iConfig.existsAs<int>("minNumberOfLayersWithMeasBeforeFiltering") ? 
     iConfig.getParameter<int>("minNumberOfLayersWithMeasBeforeFiltering") : 0;
     }
 
     if (doTracks_) trajectories_ = consumes<TrajTrackAssociationCollection>(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_) {
       oldRemovalInfo_ = consumes<ClusterRemovalInfo>(iConfig.getParameter<InputTag>("oldClusterRemovalInfo"));
       oldPxlMaskToken_ = consumes<PixelMaskContainer>(iConfig.getParameter<InputTag>("oldClusterRemovalInfo"));
       oldStrMaskToken_ = consumes<StripMaskContainer>(iConfig.getParameter<InputTag>("oldClusterRemovalInfo"));
     }
 
     if (doStripChargeCheck_) {
       rphiRecHitToken_ = consumes<SiStripRecHit2DCollection>(InputTag(stripRecHits_,"rphiRecHit"));
       stereoRecHitToken_ = consumes<SiStripRecHit2DCollection>(InputTag(stripRecHits_,"stereoRecHit"));
     }
 //    if(doPixelChargeCheck_) pixelRecHitsToken_ = consumes<SiPixelRecHitCollection>(InputTag(pixelRecHits_));
 
 }

HITrackClusterRemover::~HITrackClusterRemover ( )

Definition at line 219 of file HITrackClusterRemover.cc.

220 {

221 }

Member Function Documentation

template<typename T >

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

private

Referenced by produce().

template<typename T >

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

Definition at line 234 of file HITrackClusterRemover.cc.

References edmNew::DetSetVector< T >::begin(), edmNew::DetSetVector< T >::data(), edmNew::DetSetVector< T >::dataSize(), edmNew::DetSetVector< T >::end(), cmsHarvester::index, mergeOld(), convertSQLitetoXML_cfg::output, and edmNew::DetSetVector< T >::size().

                                                                                                    {
     typedef typename edmNew::DetSetVector<T>             DSV;
     typedef typename edmNew::DetSetVector<T>::FastFiller DSF;
     typedef typename edmNew::DetSet<T>                   DS;
     auto_ptr<DSV> output(new 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 << "HITrackClusterRemover::cleanup " << typeid(T).name() << " reference " << index << " to " << (refs.size() - 1) << std::endl;
             }
 
     }
         if (outds.empty()) outds.abort(); // not write in an empty DSV
     }
 
     if (oldRefs != 0) mergeOld(refs, *oldRefs);
     return output;
 }

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

private

Definition at line 223 of file HITrackClusterRemover.cc.

References i, and gen::n.

Referenced by cleanup().

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

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

inlineprivate

Definition at line 312 of file HITrackClusterRemover.cc.

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

                                                                                                     {
     SiStripDetId 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))) {
         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") << 
                 "HITrackClusterRemover: 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;
     
     //if(!clusterWasteSolution_) collectedPixel[detid.rawId()].insert(cluster);
    assert(collectedPixels_.size() > cluster.key());
    //assert(detid.rawId() == cluster->geographicalId()); //This condition fails
     if(!clusterWasteSolution_) 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(),detid, true);}
     else if (hitType == typeid(SiStripRecHit1D)) {
       const SiStripRecHit1D *hit1D = static_cast<const SiStripRecHit1D *>(hit);
       process(hit1D->omniClusterRef(),detid, true);
         } else if (hitType == typeid(SiStripMatchedRecHit2D)) {
             const SiStripMatchedRecHit2D *matchHit = static_cast<const SiStripMatchedRecHit2D *>(hit);
 //DBG//     cout << "Matched RecHit 2D: " << endl;
             process(matchHit->monoClusterRef(),detid, true);
             process(matchHit->stereoClusterRef(),detid, true);
         } else if (hitType == typeid(ProjectedSiStripRecHit2D)) {
             const ProjectedSiStripRecHit2D *projHit = static_cast<const ProjectedSiStripRecHit2D *>(hit);
 //DBG//     cout << "Projected RecHit 2D: " << endl;
             process(projHit->originalHit().omniClusterRef(),detid, true);
         } else throw cms::Exception("NOT IMPLEMENTED") << "Don't know how to handle " << hitType.name() << " on detid " << detid.rawId() << "\n";
     }
 }

void HITrackClusterRemover::process	(	const OmniClusterRef &	cluRef,
		SiStripDetId &	detid,
		bool	fromTrack
	)

inlineprivate

Definition at line 285 of file HITrackClusterRemover.cc.

References assert(), OmniClusterRef::cluster_strip(), clusterWasteSolution_, collectedStrips_, edm::Ref< C, T, F >::id(), edm::Ref< C, T, F >::key(), HITrackClusterRemover::ParamBlock::maxSize_, pblocks_, sensorThickness(), strips, stripSourceProdID, and DetId::subdetId().

                                                                                                          {
     SiStripRecHit2D::ClusterRef cluster = ocluster.cluster_strip();
   if (cluster.id() != stripSourceProdID) throw cms::Exception("Inconsistent Data") <<
     "HITrackClusterRemover: strip cluster ref from Product ID = " << cluster.id() <<
     " does not match with source cluster collection (ID = " << stripSourceProdID << ")\n.";
   
   uint32_t subdet = detid.subdetId();
   assert(cluster.id() == stripSourceProdID);
   if (pblocks_[subdet-1].usesSize_ && (cluster->amplitudes().size() > pblocks_[subdet-1].maxSize_)) return;
   if (!fromTrack) {
     int clusCharge=0;
     for( std::vector<uint8_t>::const_iterator iAmp = cluster->amplitudes().begin(); iAmp != cluster->amplitudes().end(); ++iAmp){
       clusCharge += *iAmp;
     }
     if (pblocks_[subdet-1].cutOnStripCharge_ && (clusCharge > (pblocks_[subdet-1].minGoodStripCharge_*sensorThickness(detid)))) return;
   }
 
   if (collectedStrips_.size()<=cluster.key())
     edm::LogError("BadCollectionSize")<<collectedStrips_.size()<<" is smaller than "<<cluster.key();
 
   assert(collectedStrips_.size() > cluster.key());
   strips[cluster.key()] = false;
   if (!clusterWasteSolution_) collectedStrips_[cluster.key()]=true;
 
 }

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

overridevirtual

Implements edm::stream::EDProducerBase.

Definition at line 381 of file HITrackClusterRemover.cc.

References assert(), cleanup(), clusterWasteSolution_, collectedPixels_, collectedStrips_, edm::AssociationMap< edm::OneToOne< std::vector< Trajectory >, reco::TrackCollection, unsigned short > >::const_iterator, KineDebug3::count(), doPixel_, doStrip_, doStripChargeCheck_, doTracks_, Exception, lumiContext::fill, filterTracks_, edm::EventSetup::get(), edm::Event::getByToken(), reco::TrackBase::hitPattern(), edm::HandleBase::id(), TrackingRecHit::isValid(), HLT_FULL_cff::labels, edm::EDConsumerBase::labelsForToken(), LogDebug, Trajectory::measurements(), mergeOld_, minNumberOfLayersWithMeasBeforeFiltering_, oldPxlMaskToken_, oldRemovalInfo_, oldStrMaskToken_, overrideTrkQuals_, HLT_FULL_cff::pixelClusters, pixelClusters_, pixels, pixelSourceProdID, process(), edm::ESHandle< class >::product(), edm::ProductLabels::productInstance, edm::Event::put(), reco::TrackBase::quality(), edm::ProductID::reset(), PixelLessLayerPairs4PixelLessTracking_cfi::rphiRecHits, rphiRecHitToken_, PixelLessLayerPairs4PixelLessTracking_cfi::stereoRecHits, stereoRecHitToken_, HLT_FULL_cff::stripClusters, stripClusters_, strips, stripSourceProdID, reco::HitPattern::trackerLayersWithMeasurement(), trackQuality_, and trajectories_.

 {
     ProductID pixelOldProdID, stripOldProdID;
 
     edm::ESHandle<TrackerGeometry> tgh;
     iSetup.get<TrackerDigiGeometryRecord>().get(tgh);
     
     Handle<edmNew::DetSetVector<SiPixelCluster> > pixelClusters;
     if (doPixel_) {
         iEvent.getByToken(pixelClusters_, pixelClusters);
         pixelSourceProdID = pixelClusters.id();
     }
 //DBG// std::cout << "HITrackClusterRemover: Read pixel " << pixelClusters_.encode() << " = ID " << pixelSourceProdID << std::endl;
 
     Handle<edmNew::DetSetVector<SiStripCluster> > stripClusters;
     if (doStrip_) {
         iEvent.getByToken(stripClusters_, stripClusters);
         stripSourceProdID = stripClusters.id();
     }
 //DBG// std::cout << "HITrackClusterRemover: Read strip " << stripClusters_.encode() << " = ID " << stripSourceProdID << std::endl;
 
     auto_ptr<ClusterRemovalInfo> cri;
     if (clusterWasteSolution_){
       if (doStrip_ && doPixel_) cri.reset(new ClusterRemovalInfo(pixelClusters, stripClusters));
       else if (doStrip_) cri.reset(new ClusterRemovalInfo(stripClusters));
       else if (doPixel_) cri.reset(new ClusterRemovalInfo(pixelClusters));
     }
 
     Handle<ClusterRemovalInfo> oldRemovalInfo;
     if (mergeOld_ && clusterWasteSolution_) { 
         iEvent.getByToken(oldRemovalInfo_, oldRemovalInfo); 
         // Check ProductIDs
         if ( (oldRemovalInfo->stripNewRefProd().id() == stripClusters.id()) &&
              (oldRemovalInfo->pixelNewRefProd().id() == pixelClusters.id()) ) {
 
             cri->getOldClustersFrom(*oldRemovalInfo);
 
             pixelOldProdID = oldRemovalInfo->pixelRefProd().id();
             stripOldProdID = oldRemovalInfo->stripRefProd().id();
 
         } else {
 
         edm::EDConsumerBase::Labels labels;
         labelsForToken(oldRemovalInfo_,labels);
             throw cms::Exception("Inconsistent Data") << "HITrackClusterRemover: " <<
                 "Input collection product IDs are [pixel: " << pixelClusters.id() << ", strip: " << stripClusters.id() << "] \n" <<
                 "\t but the *old* ClusterRemovalInfo " << labels.productInstance << " refers as 'new product ids' to " <<
                     "[pixel: " << oldRemovalInfo->pixelNewRefProd().id() << ", strip: " << oldRemovalInfo->stripNewRefProd().id() << "]\n" << 
                 "NOTA BENE: when running HITrackClusterRemover with an old ClusterRemovalInfo the hits in the trajectory MUST be already re-keyed.\n";
         }
     } else { // then Old == Source
         pixelOldProdID = pixelSourceProdID;
         stripOldProdID = stripSourceProdID;
     }
 
     if (doStrip_) {
       strips.resize(stripClusters->dataSize()); fill(strips.begin(), strips.end(), true);
     }
     if (doPixel_) {
       pixels.resize(pixelClusters->dataSize()); fill(pixels.begin(), pixels.end(), true);
     }
     if(mergeOld_) {
       edm::Handle<PixelMaskContainer> oldPxlMask;
       edm::Handle<StripMaskContainer> oldStrMask;
       iEvent.getByToken(oldPxlMaskToken_ ,oldPxlMask);
       iEvent.getByToken(oldStrMaskToken_ ,oldStrMask);
       LogDebug("HITrackClusterRemover")<<"to merge in, "<<oldStrMask->size()<<" strp and "<<oldPxlMask->size()<<" pxl";
       oldStrMask->copyMaskTo(collectedStrips_);
       oldPxlMask->copyMaskTo(collectedPixels_);
       assert(stripClusters->dataSize()>=collectedStrips_.size());
       collectedStrips_.resize(stripClusters->dataSize(), false);
     }else {
       collectedStrips_.resize(stripClusters->dataSize(), false);
       collectedPixels_.resize(pixelClusters->dataSize(), false);
     } 
 
     if (doTracks_) {
 
       Handle<TrajTrackAssociationCollection> trajectories_totrack; 
       iEvent.getByToken(trajectories_,trajectories_totrack);
 
       std::vector<Handle<edm::ValueMap<int> > > quals;
       if ( overrideTrkQuals_.size() > 0) {
     quals.resize(1);
     iEvent.getByToken(overrideTrkQuals_[0],quals[0]);
       }
 
       TrajTrackAssociationCollection::const_iterator asst=trajectories_totrack->begin();
    
       for ( ; asst!=trajectories_totrack->end();++asst){
     const Track & track = *(asst->val);
     if (filterTracks_) {
       bool goodTk = true;
       if ( quals.size()!=0) {
         int qual=(*(quals[0]))[asst->val];
         if ( qual < 0 ) {goodTk=false;}
         //note that this does not work for some trackquals (goodIterative  or undefQuality)
         else
           goodTk = ( qual & (1<<trackQuality_))>>trackQuality_;
       }
       else
         goodTk=(track.quality(trackQuality_));
       if ( !goodTk) continue;
       if(track.hitPattern().trackerLayersWithMeasurement() < minNumberOfLayersWithMeasBeforeFiltering_) continue;
     }
     const Trajectory &tj = *(asst->key);
     const vector<TrajectoryMeasurement> &tms = tj.measurements();
     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; 
       process( hit, itm->estimate() , tgh.product());
     }
       }
     }
 
     if (doStripChargeCheck_) {
       edm::Handle<SiStripRecHit2DCollection> rechitsrphi;
       iEvent.getByToken(rphiRecHitToken_, rechitsrphi);
       const SiStripRecHit2DCollection::DataContainer * rphiRecHits = & (rechitsrphi).product()->data();
       for(  SiStripRecHit2DCollection::DataContainer::const_iterator
           recHit = rphiRecHits->begin(); recHit!= rphiRecHits->end(); recHit++){
     SiStripDetId detid = recHit->geographicalId(); 
     process(recHit->omniClusterRef(),detid,false);
       }
       edm::Handle<SiStripRecHit2DCollection> rechitsstereo;
       iEvent.getByToken(stereoRecHitToken_, rechitsstereo);
       const SiStripRecHit2DCollection::DataContainer * stereoRecHits = & (rechitsstereo).product()->data();
       for(  SiStripRecHit2DCollection::DataContainer::const_iterator
           recHit = stereoRecHits->begin(); recHit!= stereoRecHits->end(); recHit++){
     SiStripDetId detid = recHit->geographicalId(); 
     process(recHit->omniClusterRef(),detid,false);
       }
 
     }
 //    if(doPixelChargeCheck_) {
 //  edm::Handle<SiPixelRecHitCollection> pixelrechits;
 //  iEvent.getByToken(pixelRecHitsToken_,pixelrechits);
 //    }
 
     if (doPixel_ && clusterWasteSolution_) {
         auto_ptr<edmNew::DetSetVector<SiPixelCluster> > newPixelClusters = cleanup(*pixelClusters, pixels, 
                     cri->pixelIndices(), mergeOld_ ? &oldRemovalInfo->pixelIndices() : 0);
         OrphanHandle<edmNew::DetSetVector<SiPixelCluster> > newPixels = iEvent.put(newPixelClusters); 
 //DBG// std::cout << "HITrackClusterRemover: Wrote pixel " << newPixels.id() << " from " << pixelSourceProdID << std::endl;
         cri->setNewPixelClusters(newPixels);
     }
     if (doStrip_ && clusterWasteSolution_) {
         auto_ptr<edmNew::DetSetVector<SiStripCluster> > newStripClusters = cleanup(*stripClusters, strips, 
                     cri->stripIndices(), mergeOld_ ? &oldRemovalInfo->stripIndices() : 0);
         OrphanHandle<edmNew::DetSetVector<SiStripCluster> > newStrips = iEvent.put(newStripClusters); 
 //DBG// std::cout << "HITrackClusterRemover: Wrote strip " << newStrips.id() << " from " << stripSourceProdID << std::endl;
         cri->setNewStripClusters(newStrips);
     }
 
     
     if (clusterWasteSolution_) {
       //      double fraction_pxl= cri->pixelIndices().size() / (double) pixels.size();
       //      double fraction_strp= cri->stripIndices().size() / (double) strips.size();
       //      edm::LogWarning("HITrackClusterRemover")<<" fraction: " << fraction_pxl <<" "<<fraction_strp;
       iEvent.put(cri);
     }
 
     pixels.clear(); strips.clear(); 
 
     if (!clusterWasteSolution_){
       //auto_ptr<edmNew::DetSetVector<SiPixelClusterRefNew> > removedPixelClsuterRefs(new edmNew::DetSetVector<SiPixelClusterRefNew>());
       //auto_ptr<edmNew::DetSetVector<SiStripRecHit1D::ClusterRef> > removedStripClsuterRefs(new edmNew::DetSetVector<SiStripRecHit1D::ClusterRef>());
       
       std::auto_ptr<StripMaskContainer> removedStripClusterMask(
          new StripMaskContainer(edm::RefProd<edmNew::DetSetVector<SiStripCluster> >(stripClusters),collectedStrips_));
       LogDebug("HITrackClusterRemover")<<"total strip to skip: "<<std::count(collectedStrips_.begin(),collectedStrips_.end(),true);
       // std::cout << "HITrackClusterRemover " <<"total strip to skip: "<<std::count(collectedStrips_.begin(),collectedStrips_.end(),true) <<std::endl;
        iEvent.put( removedStripClusterMask );
 
       std::auto_ptr<PixelMaskContainer> removedPixelClusterMask(
          new PixelMaskContainer(edm::RefProd<edmNew::DetSetVector<SiPixelCluster> >(pixelClusters),collectedPixels_));      
       LogDebug("HITrackClusterRemover")<<"total pxl to skip: "<<std::count(collectedPixels_.begin(),collectedPixels_.end(),true);
       iEvent.put( removedPixelClusterMask );
       
     }
     collectedStrips_.clear();
     collectedPixels_.clear();
 
 }

void HITrackClusterRemover::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 120 of file HITrackClusterRemover.cc.

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

Referenced by HITrackClusterRemover().

 {
     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;
         }
     }
 }

float HITrackClusterRemover::sensorThickness ( const SiStripDetId & detid ) const

private

Definition at line 273 of file HITrackClusterRemover.cc.

References SiStripDetId::moduleGeometry(), PixelSubdetector::PixelBarrel, DetId::subdetId(), SiStripDetId::TIB, SiStripDetId::TOB, SiStripDetId::W5, SiStripDetId::W6, and SiStripDetId::W7.

Referenced by process().

 {
   if (detid.subdetId()>=SiStripDetId::TIB) {
     if (detid.subdetId()==SiStripDetId::TOB) return 0.047;
     if (detid.moduleGeometry()==SiStripDetId::W5 || detid.moduleGeometry()==SiStripDetId::W6 ||
         detid.moduleGeometry()==SiStripDetId::W7)
     return 0.047;
     return 0.029; // so it is TEC ring 1-4 or TIB or TOB;
   } else if (detid.subdetId()==PixelSubdetector::PixelBarrel) return 0.0285;
   else return 0.027;
 }