#include <CaloCleaner.h>

Inheritance diagram for CaloCleaner< T >:

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

	~CaloCleaner () 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::SortedCollection< T >	RecHitCollection

Private Member Functions
void	fill_correction_map (TrackDetMatchInfo , std::map< uint32_t, float > )

template<>
void	fill_correction_map (TrackDetMatchInfo info, std::map< uint32_t, float > cor_map)

template<>
void	fill_correction_map (TrackDetMatchInfo info, std::map< uint32_t, float > cor_map)

template<>
void	fill_correction_map (TrackDetMatchInfo info, std::map< uint32_t, float > cor_map)

template<>
void	fill_correction_map (TrackDetMatchInfo info, std::map< uint32_t, float > cor_map)

template<>
void	fill_correction_map (TrackDetMatchInfo info, std::map< uint32_t, float > cor_map)

template<>
void	fill_correction_map (TrackDetMatchInfo info, std::map< uint32_t, float > cor_map)

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

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

bool	is_preshower_

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

TrackAssociatorParameters	parameters_

TrackDetectorAssociator	trackAssociator_

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 T>
class CaloCleaner< T >

Clean collections of calorimeter recHits (detectors supported at the moment: EB/EE, HB/HE and HO)

Author: Tomasz Maciej Frueboes; Christian Veelken, LLR

Clean Up from STefan Wayand, KIT

Definition at line 36 of file CaloCleaner.h.

Member Typedef Documentation

◆ RecHitCollection

template<typename T >

typedef edm::SortedCollection<T> CaloCleaner< T >::RecHitCollection

private

Definition at line 44 of file CaloCleaner.h.

Constructor & Destructor Documentation

◆ CaloCleaner()

template<typename T >

CaloCleaner< T >::CaloCleaner ( const edm::ParameterSet & iConfig )

explicit

Definition at line 58 of file CaloCleaner.h.

     : 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());
   }
  
   is_preshower_ = iConfig.getUntrackedParameter<bool>("is_preshower", false);
   edm::ParameterSet parameters = iConfig.getParameter<edm::ParameterSet>("TrackAssociatorParameters");
   edm::ConsumesCollector iC = consumesCollector();
   parameters_.loadParameters(parameters, iC);
   //trackAssociator_.useDefaultPropagator();
 }

References edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), CaloCleaner< T >::inputs_, CaloCleaner< T >::is_preshower_, TrackAssociatorParameters::loadParameters(), and CaloCleaner< T >::parameters_.

◆ ~CaloCleaner()

template<typename T >

CaloCleaner< T >::~CaloCleaner ( )

override

Definition at line 74 of file CaloCleaner.h.

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

Member Function Documentation

◆ fill_correction_map() [1/7]

template<typename T >

void CaloCleaner< T >::fill_correction_map	(	TrackDetMatchInfo *	,
		std::map< uint32_t, float > *
	)

private

Definition at line 22 of file CaloCleaner.cc.

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

References cms::cuda::assert().

◆ fill_correction_map() [2/7]

template<>

void CaloCleaner< EcalRecHit >::fill_correction_map	(	TrackDetMatchInfo *	info,
		std::map< uint32_t, float > *	cor_map
	)

private

Definition at line 28 of file CaloCleaner.cc.

                                                                                                            {
   if (is_preshower_) {
     for (std::vector<DetId>::const_iterator detId = info->crossedPreshowerIds.begin();
          detId != info->crossedPreshowerIds.end();
          ++detId) {
       (*cor_map)[detId->rawId()] = 9999999;  // just remove all energy (Below 0 is not possible)
     }
   } else {
     for (std::vector<const EcalRecHit *>::const_iterator hit = info->crossedEcalRecHits.begin();
          hit != info->crossedEcalRecHits.end();
          hit++) {
       //    (*cor_map) [(*hit)->detid().rawId()] +=(*hit)->energy();
       (*cor_map)[(*hit)->detid().rawId()] = (*hit)->energy();
     }
   }
 }

References info().

◆ fill_correction_map() [3/7]

template<>

void CaloCleaner< HBHERecHit >::fill_correction_map	(	TrackDetMatchInfo *	info,
		std::map< uint32_t, float > *	cor_map
	)

private

Definition at line 46 of file CaloCleaner.cc.

                                                                                                            {
   for (std::vector<const HBHERecHit *>::const_iterator hit = info->crossedHcalRecHits.begin();
        hit != info->crossedHcalRecHits.end();
        hit++) {
     (*cor_map)[(*hit)->detid().rawId()] = (*hit)->energy();
   }
 }

References info().

◆ fill_correction_map() [4/7]

template<>

void CaloCleaner< HORecHit >::fill_correction_map	(	TrackDetMatchInfo *	info,
		std::map< uint32_t, float > *	cor_map
	)

private

Definition at line 55 of file CaloCleaner.cc.

                                                                                                          {
   for (std::vector<const HORecHit *>::const_iterator hit = info->crossedHORecHits.begin();
        hit != info->crossedHORecHits.end();
        hit++) {
     (*cor_map)[(*hit)->detid().rawId()] = (*hit)->energy();
   }
 }

References info().

◆ fill_correction_map() [5/7]

template<>

void CaloCleaner< HFRecHit >::fill_correction_map	(	TrackDetMatchInfo *	info,
		std::map< uint32_t, float > *	cor_map
	)

private

Definition at line 64 of file CaloCleaner.cc.

                                                                                                          {
   return;  // No corrections for HF
 }

◆ fill_correction_map() [6/7]

template<>

void CaloCleaner< CastorRecHit >::fill_correction_map	(	TrackDetMatchInfo *	info,
		std::map< uint32_t, float > *	cor_map
	)

private

Definition at line 69 of file CaloCleaner.cc.

                                                                                                              {
   return;  // No corrections for Castor
 }

◆ fill_correction_map() [7/7]

template<>

void CaloCleaner< ZDCRecHit >::fill_correction_map	(	TrackDetMatchInfo *	info,
		std::map< uint32_t, float > *	cor_map
	)

private

Definition at line 74 of file CaloCleaner.cc.

                                                                                                           {
   return;  // No corrections for Castor
 }

◆ produce()

template<typename T >

void CaloCleaner< T >::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 79 of file CaloCleaner.h.

                                                                           {
   edm::ESHandle<Propagator> propagator;
   iSetup.get<TrackingComponentsRecord>().get("SteppingHelixPropagatorAny", propagator);
   trackAssociator_.setPropagator(propagator.product());
  
   edm::Handle<edm::View<pat::Muon> > muonHandle;
   iEvent.getByToken(mu_input_, muonHandle);
   edm::View<pat::Muon> muons = *muonHandle;
  
   std::map<uint32_t, float> correction_map;
  
   // Fill the correction map
   for (edm::View<pat::Muon>::const_iterator iMuon = muons.begin(); iMuon != muons.end(); ++iMuon) {
     // get the basic informaiton like fill reco mouon does
     //     RecoMuon/MuonIdentification/plugins/MuonIdProducer.cc
     const reco::Track* track = nullptr;
     if (iMuon->track().isNonnull())
       track = iMuon->track().get();
     else if (iMuon->standAloneMuon().isNonnull())
       track = iMuon->standAloneMuon().get();
     else
       throw cms::Exception("FatalError")
           << "Failed to fill muon id information for a muon with undefined references to tracks";
     TrackDetMatchInfo info =
         trackAssociator_.associate(iEvent, iSetup, *track, parameters_, TrackDetectorAssociator::Any);
     fill_correction_map(&info, &correction_map);
   }
  
   // Copy the old collection and correct if necessary
   for (auto input_ : inputs_) {
     std::unique_ptr<RecHitCollection> recHitCollection_output(new RecHitCollection());
     edm::Handle<RecHitCollection> recHitCollection;
     // iEvent.getByToken(input_.second[0], recHitCollection);
     iEvent.getByToken(input_.second, recHitCollection);
     for (typename RecHitCollection::const_iterator recHit = recHitCollection->begin();
          recHit != recHitCollection->end();
          ++recHit) {
       if (correction_map[recHit->detid().rawId()] > 0) {
         float new_energy = recHit->energy() - correction_map[recHit->detid().rawId()];
         if (new_energy <= 0)
           continue;  // Do not save empty Hits
         T newRecHit(*recHit);
         newRecHit.setEnergy(new_energy);
         recHitCollection_output->push_back(newRecHit);
       } else {
         recHitCollection_output->push_back(*recHit);
       }
       /* For the inveted collection   
      if (correction_map[recHit->detid().rawId()] > 0){
     float new_energy =   correction_map[recHit->detid().rawId()];
     if (new_energy < 0) new_energy =0;
     T newRecHit(*recHit);
     newRecHit.setEnergy(new_energy); 
     recHitCollection_output->push_back(newRecHit);
       }*/
     }
     // Save the new collection
     recHitCollection_output->sort();
     iEvent.put(std::move(recHitCollection_output), input_.first);
   }
 }