#include <MuonDetCleaner.h>

Inheritance diagram for MuonDetCleaner< T1, T2 >:

Public Member Functions
	MuonDetCleaner (const edm::ParameterSet &)

	~MuonDetCleaner () override

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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Private Types
typedef edm::RangeMap< T1, edm::OwnVector< T2 > >	RecHitCollection

Private Member Functions
bool	checkrecHit (const TrackingRecHit &)

template<>
bool	checkrecHit (const TrackingRecHit &recHit)

template<>
bool	checkrecHit (const TrackingRecHit &recHit)

template<>
bool	checkrecHit (const TrackingRecHit &recHit)

void	fillVetoHits (const TrackingRecHit &, std::vector< uint32_t > *)

template<>
uint32_t	getRawDetId (const CSCRecHit2D &recHit)

template<>
uint32_t	getRawDetId (const DTRecHit1DPair &recHit)

template<>
uint32_t	getRawDetId (const RPCRecHit &recHit)

uint32_t	getRawDetId (const T2 &)

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

Private Attributes
std::map< std::string, edm::EDGetTokenT < RecHitCollection > >	inputs_

const edm::EDGetTokenT < edm::View< pat::Muon > >	mu_input_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T...>

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T...>

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

template<typename T1, typename T2>
class MuonDetCleaner< T1, T2 >

Clean collections of hits in muon detectors (CSC, DT and RPC) for original Zmumu event and "embedded" simulated tau decay products

Author: Christian Veelken, LLR

Clean Up from STefan Wayand, KIT

Definition at line 35 of file MuonDetCleaner.h.

Member Typedef Documentation

template<typename T1 , typename T2 >

typedef edm::RangeMap<T1, edm::OwnVector<T2> > MuonDetCleaner< T1, T2 >::RecHitCollection

private

Definition at line 43 of file MuonDetCleaner.h.

Constructor & Destructor Documentation

template<typename T1 , typename T2 >

MuonDetCleaner< T1, T2 >::MuonDetCleaner ( const edm::ParameterSet & iConfig )

explicit

Definition at line 55 of file MuonDetCleaner.h.

References edm::ParameterSet::getParameter(), and MuonDetCleaner< T1, T2 >::inputs_.

     : mu_input_(consumes<edm::View<pat::Muon> >(iConfig.getParameter<edm::InputTag>("MuonCollection"))) {
   std::vector<edm::InputTag> inCollections = iConfig.getParameter<std::vector<edm::InputTag> >("oldCollection");
   for (const auto& inCollection : inCollections) {
     inputs_[inCollection.instance()] = consumes<RecHitCollection>(inCollection);
     produces<RecHitCollection>(inCollection.instance());
   }
 }

template<typename T1 , typename T2 >

MuonDetCleaner< T1, T2 >::~MuonDetCleaner ( )

override

Definition at line 65 of file MuonDetCleaner.h.

                                         {
   // nothing to be done yet...
 }

Member Function Documentation

template<typename T1 , typename T2 >

bool MuonDetCleaner< T1, T2 >::checkrecHit ( const TrackingRecHit & recHit )

private

Definition at line 46 of file MuonDetCleaner.cc.

References cms::cuda::assert().

                                                                      {
   edm::LogError("TauEmbedding") << "!!!! Please add the checkrecHit for the individual class templates " assert(0);
 }

template<>

bool MuonDetCleaner< CSCDetId, CSCRecHit2D >::checkrecHit ( const TrackingRecHit & recHit )

private

Definition at line 51 of file MuonDetCleaner.cc.

                                                                                     {
   const std::type_info& hit_type = typeid(recHit);
   if (hit_type == typeid(CSCSegment)) {
     return true;
   }  // This should be the default one (which are included in the global (outer) muon track)
   else if (hit_type == typeid(CSCRecHit2D)) {
     return true;
   }
   //else {std::cout<<"else "<<hit_type.name()<<std::endl;}
   return false;
 }

template<>

bool MuonDetCleaner< DTLayerId, DTRecHit1DPair >::checkrecHit ( const TrackingRecHit & recHit )

private

Definition at line 64 of file MuonDetCleaner.cc.

                                                                                         {
   const std::type_info& hit_type = typeid(recHit);
   if (hit_type == typeid(DTRecSegment4D)) {
     return true;
   }  // This should be the default one (which are included in the global (outer) muon track)
   else if (hit_type == typeid(DTRecHit1D)) {
     return true;
   } else if (hit_type == typeid(DTSLRecCluster)) {
     return true;
   } else if (hit_type == typeid(DTSLRecSegment2D)) {
     return true;
   }
   // else {std::cout<<"else "<<hit_type.name()<<std::endl;}
   return false;
 }

template<>

bool MuonDetCleaner< RPCDetId, RPCRecHit >::checkrecHit ( const TrackingRecHit & recHit )

private

Definition at line 81 of file MuonDetCleaner.cc.

                                                                                   {
   const std::type_info& hit_type = typeid(recHit);
   if (hit_type == typeid(RPCRecHit)) {
     return true;
   }  // This should be the default one (which are included in the global (outer) muon track)
   //else {std::cout<<"else "<<hit_type.name()<<std::endl;}
   return false;
 }

template<typename T1 , typename T2 >

void MuonDetCleaner< T1, T2 >::fillVetoHits	(	const TrackingRecHit &	rh,
		std::vector< uint32_t > *	HitsList
	)

private

Definition at line 132 of file MuonDetCleaner.h.

References TrackingRecHit::rawId(), and TrackingRecHit::recHits().

                                                                                                  {
   std::vector<const TrackingRecHit*> rh_components = rh.recHits();
   if (rh_components.empty()) {
     HitsList->push_back(rh.rawId());
   } else {
     for (std::vector<const TrackingRecHit*>::const_iterator rh_component = rh_components.begin();
          rh_component != rh_components.end();
          ++rh_component) {
       fillVetoHits(**rh_component, HitsList);
     }
   }
 }

template<>

uint32_t MuonDetCleaner< CSCDetId, CSCRecHit2D >::getRawDetId ( const CSCRecHit2D & recHit )

private

Definition at line 27 of file MuonDetCleaner.cc.

References CSCRecHit2D::cscDetId(), and DetId::rawId().

                                                                                      {
   return recHit.cscDetId().rawId();
 }

template<>

uint32_t MuonDetCleaner< DTLayerId, DTRecHit1DPair >::getRawDetId ( const DTRecHit1DPair & recHit )

private

Definition at line 32 of file MuonDetCleaner.cc.

References DTRecHit1DPair::geographicalId(), and DetId::rawId().

                                                                                             {
   return recHit.geographicalId().rawId();
 }

template<>

uint32_t MuonDetCleaner< RPCDetId, RPCRecHit >::getRawDetId ( const RPCRecHit & recHit )

private

Definition at line 37 of file MuonDetCleaner.cc.

References DetId::rawId(), and RPCRecHit::rpcId().

                                                                                  {
   return recHit.rpcId().rawId();
 }

template<typename T1 , typename T2 >

uint32_t MuonDetCleaner< T1, T2 >::getRawDetId ( const T2 & recHit )

private

Definition at line 21 of file MuonDetCleaner.cc.

References cms::cuda::assert().

                                                              {
   assert(0);  // CV: make sure general function never gets called;
               //     always use template specializations
 }

template<typename T1 , typename T2 >

void MuonDetCleaner< T1, T2 >::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	es
	)

overrideprivate

Definition at line 70 of file MuonDetCleaner.h.

References cms::cuda::assert(), edm::View< T >::begin(), edm::View< T >::end(), spr::find(), edm::Event::getByToken(), eostools::move(), patZpeak::muons, convertSQLitetoXML_cfg::output, edm::Event::put(), reco::Track::recHitsBegin(), reco::Track::recHitsEnd(), and HLT_FULL_cff::track.

                                                                               {
   std::map<T1, std::vector<T2> > recHits_output;  // This data format is easyer to handle
   std::vector<uint32_t> vetoHits;
 
   // First fill the veto RecHits colletion with the Hits from the input muons
   edm::Handle<edm::View<pat::Muon> > muonHandle;
   iEvent.getByToken(mu_input_, muonHandle);
   edm::View<pat::Muon> muons = *muonHandle;
   for (edm::View<pat::Muon>::const_iterator iMuon = muons.begin(); iMuon != muons.end(); ++iMuon) {
     const reco::Track* track = nullptr;
     if (iMuon->isGlobalMuon())
       track = iMuon->outerTrack().get();
     else if (iMuon->isStandAloneMuon())
       track = iMuon->outerTrack().get();
     else if (iMuon->isRPCMuon())
       track = iMuon->innerTrack().get();  // To add, try to access the rpc track
     else if (iMuon->isTrackerMuon())
       track = iMuon->innerTrack().get();
     else {
       edm::LogError("TauEmbedding") << "The imput muon: " << (*iMuon)
                                     << " must be either global or does or be tracker muon";
       assert(0);
     }
 
     for (trackingRecHit_iterator hitIt = track->recHitsBegin(); hitIt != track->recHitsEnd(); ++hitIt) {
       const TrackingRecHit& murechit = **hitIt;  // Base class for all rechits
       if (!(murechit).isValid())
         continue;
       if (!checkrecHit(murechit))
         continue;                         // Check if the hit belongs to a specifc detector section
       fillVetoHits(murechit, &vetoHits);  // Go back to the very basic rechits
     }
   }
 
   // Now this can also handle different instance
   for (auto input_ : inputs_) {
     // Second read in the RecHit Colltection which is to be replaced, without the vetoRecHits
     typedef edm::Handle<RecHitCollection> RecHitCollectionHandle;
     RecHitCollectionHandle RecHitinput;
     iEvent.getByToken(input_.second, RecHitinput);
     for (typename RecHitCollection::const_iterator recHit = RecHitinput->begin(); recHit != RecHitinput->end();
          ++recHit) {  // loop over the basic rec hit collection (DT CSC or RPC)
       //if (find(vetoHits.begin(),vetoHits.end(),getRawDetId(*recHit)) == vetoHits.end()) continue; // For the invertec selcetion
       if (find(vetoHits.begin(), vetoHits.end(), getRawDetId(*recHit)) != vetoHits.end())
         continue;  // If the hit is not in the
       T1 detId(getRawDetId(*recHit));
       recHits_output[detId].push_back(*recHit);
     }
 
     // Last step savet the output in the CMSSW Data Format
     std::unique_ptr<RecHitCollection> output(new RecHitCollection());
     for (typename std::map<T1, std::vector<T2> >::const_iterator recHit = recHits_output.begin();
          recHit != recHits_output.end();
          ++recHit) {
       output->put(recHit->first, recHit->second.begin(), recHit->second.end());
     }
     output->post_insert();
     iEvent.put(std::move(output), input_.first);
   }
 }