CaloRecHitMixer< T > Class Template Reference

#include <CaloRecHitMixer.h>

Inheritance diagram for CaloRecHitMixer< T >:

Classes
struct	todoListEntryType

Public Member Functions
	CaloRecHitMixer (const edm::ParameterSet &)
	~CaloRecHitMixer ()
Public Member Functions inherited from edm::EDProducer
	EDProducer ()
ModuleDescription const &	moduleDescription () const
virtual	~EDProducer ()
Public Member Functions inherited from edm::ProducerBase
	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
	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 (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const
bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)
virtual	~EDConsumerBase ()

Private Types
enum	{ kAbsolute }
typedef std::map< uint32_t, float >	detIdToFloatMap
typedef std::map< uint32_t, CaloRecHitMixer_mixedRecHitInfoType < T > >	detIdToMixedRecHitInfoMap
typedef edm::SortedCollection< T >	RecHitCollection

Private Member Functions
template<>
EcalRecHit	buildRecHit (const CaloRecHitMixer_mixedRecHitInfoType< EcalRecHit > &recHitInfo)
T	buildRecHit (const CaloRecHitMixer_mixedRecHitInfoType< T > &)
template<>
HBHERecHit	buildRecHit (const CaloRecHitMixer_mixedRecHitInfoType< HBHERecHit > &recHitInfo)
template<>
HORecHit	buildRecHit (const CaloRecHitMixer_mixedRecHitInfoType< HORecHit > &recHitInfo)
template<>
HFRecHit	buildRecHit (const CaloRecHitMixer_mixedRecHitInfoType< HFRecHit > &recHitInfo)
template<>
CastorRecHit	buildRecHit (const CaloRecHitMixer_mixedRecHitInfoType< CastorRecHit > &recHitInfo)
virtual void	produce (edm::Event &, const edm::EventSetup &)
void	updateRecHitInfos (const RecHitCollection &, int)

Private Attributes
detIdToMixedRecHitInfoMap	mixedRecHitInfos_
std::string	moduleLabel_
edm::InputTag	srcEnergyDepositMapMuMinus_
edm::InputTag	srcEnergyDepositMapMuPlus_
std::vector< todoListEntryType >	todoList_
int	typeEnergyDepositMap_
int	verbosity_

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType
Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList
Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
Protected Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
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

template<typename T>
class CaloRecHitMixer< T >

Merge collections of calorimeter recHits for original Zmumu event and "embedded" simulated tau decay products (detectors supported at the moment: EB/EE, HB/HE and HO)

Author

Tomasz Maciej Frueboes; Christian Veelken, LLR

Version

Revision:

1.9

Id:

CaloRecHitMixer.h,v 1.9 2013/03/23 09:12:51 veelken Exp

Definition at line 47 of file CaloRecHitMixer.h.

Member Typedef Documentation

template<typename T >

typedef std::map<uint32_t, float> CaloRecHitMixer< T >::detIdToFloatMap

private

Definition at line 83 of file CaloRecHitMixer.h.

template<typename T >

typedef std::map<uint32_t, CaloRecHitMixer_mixedRecHitInfoType<T> > CaloRecHitMixer< T >::detIdToMixedRecHitInfoMap

private

Definition at line 72 of file CaloRecHitMixer.h.

template<typename T >

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

private

Definition at line 70 of file CaloRecHitMixer.h.

Member Enumeration Documentation

template<typename T >

anonymous enum

private

Enumerator
kAbsolute

Definition at line 80 of file CaloRecHitMixer.h.

{ kAbsolute };

Constructor & Destructor Documentation

template<typename T >

CaloRecHitMixer< T >::CaloRecHitMixer ( const edm::ParameterSet &  cfg )

explicit

Definition at line 89 of file CaloRecHitMixer.h.

References edm::hlt::Exception, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), edm::InputTag::instance(), CaloRecHitMixer< T >::kAbsolute, CaloRecHitMixer< T >::todoListEntryType::killNegEnergyAfterMixing_, CaloRecHitMixer< T >::todoListEntryType::killNegEnergyBeforeMixing1_, CaloRecHitMixer< T >::todoListEntryType::killNegEnergyBeforeMixing2_, CaloRecHitMixer< T >::todoListEntryType::kSubtractAfterMixing, CaloRecHitMixer< T >::todoListEntryType::kSubtractFromCollection1BeforeMixing, CaloRecHitMixer< T >::todoListEntryType::kSubtractFromCollection2BeforeMixing, CaloRecHitMixer< T >::todoListEntryType::muonEnSutractionMode_, CaloRecHitMixer< T >::todoListEntryType::srcRecHitCollection1_, CaloRecHitMixer< T >::todoListEntryType::srcRecHitCollection2_, AlCaHLTBitMon_QueryRunRegistry::string, CaloRecHitMixer< T >::todoList_, CaloRecHitMixer< T >::typeEnergyDepositMap_, and CaloRecHitMixer< T >::verbosity_.

  : moduleLabel_(cfg.getParameter<std::string>("@module_label")),    
    srcEnergyDepositMapMuPlus_(cfg.getParameter<edm::InputTag>("srcEnergyDepositMapMuPlus")),
    srcEnergyDepositMapMuMinus_(cfg.getParameter<edm::InputTag>("srcEnergyDepositMapMuMinus"))
{
  edm::VParameterSet todoList = cfg.getParameter<edm::VParameterSet>("todo");
  if ( todoList.size() == 0 ) {
    throw cms::Exception("Configuration") 
      << "Empty to-do list !!\n";
  }
  
  std::string typeEnergyDepositMap_string = cfg.getParameter<std::string>("typeEnergyDepositMap");
  if ( typeEnergyDepositMap_string == "absolute" ) typeEnergyDepositMap_ = kAbsolute;
  else throw cms::Exception("Configuration") 
    << "Invalid Configuration parameter 'typeEnergyDepositMap' = " << typeEnergyDepositMap_string << " !!\n";
 
  for ( edm::VParameterSet::const_iterator todoItem = todoList.begin();
    todoItem != todoList.end(); ++todoItem ) {
    todoListEntryType todoListEntry;
    todoListEntry.srcRecHitCollection1_ = todoItem->getParameter<edm::InputTag>("collection1");
    todoListEntry.killNegEnergyBeforeMixing1_ = todoItem->getParameter<bool>("killNegEnergyBeforeMixing1");
    todoListEntry.srcRecHitCollection2_ = todoItem->getParameter<edm::InputTag>("collection2");
    todoListEntry.killNegEnergyBeforeMixing2_ = todoItem->getParameter<bool>("killNegEnergyBeforeMixing2");
    std::string muonEnSutractionMode_string = todoItem->getParameter<std::string>("muonEnSutractionMode");
    if       ( muonEnSutractionMode_string == "subtractFromCollection1BeforeMixing" ) todoListEntry.muonEnSutractionMode_ = todoListEntryType::kSubtractFromCollection1BeforeMixing;
    else if  ( muonEnSutractionMode_string == "subtractFromCollection2BeforeMixing" ) todoListEntry.muonEnSutractionMode_ = todoListEntryType::kSubtractFromCollection2BeforeMixing;    
    else if  ( muonEnSutractionMode_string == "subtractAfterMixing"                 ) todoListEntry.muonEnSutractionMode_ = todoListEntryType::kSubtractAfterMixing;
    else throw cms::Exception("Configuration") 
      << "Invalid Configuration parameter 'muonEnSutractionMode' = " << muonEnSutractionMode_string << " !!\n";
    todoListEntry.killNegEnergyAfterMixing_ = todoItem->getParameter<bool>("killNegEnergyAfterMixing");
    
    std::string instanceLabel1 = todoListEntry.srcRecHitCollection1_.instance();
    std::string instanceLabel2 = todoListEntry.srcRecHitCollection2_.instance();
    if ( instanceLabel1 != instanceLabel2 ) {
      throw cms::Exception("Configuration") 
    << "Mismatch in Instance labels for collection 1 = " << instanceLabel1 << " and 2 = " << instanceLabel2 << " !!\n";
    }
    
    todoList_.push_back(todoListEntry); 
    
    produces<RecHitCollection>(instanceLabel1);
    std::string instanceLabel_removedEnergyMuMinus = "removedEnergyMuMinus";
    if ( instanceLabel1 != "" ) instanceLabel_removedEnergyMuMinus.append("#").append(instanceLabel1);
    produces<double>(instanceLabel_removedEnergyMuMinus.data());
    std::string instanceLabel_removedEnergyMuPlus = "removedEnergyMuPlus";
    if ( instanceLabel1 != "" ) instanceLabel_removedEnergyMuPlus.append("#").append(instanceLabel1);
    produces<double>(instanceLabel_removedEnergyMuPlus.data());
  }  
  
  verbosity_ = ( cfg.exists("verbosity") ) ?
    cfg.getParameter<int>("verbosity") : 0;
}

template<typename T >

CaloRecHitMixer< T >::~CaloRecHitMixer

(

)

Definition at line 143 of file CaloRecHitMixer.h.

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

Member Function Documentation

template<>

EcalRecHit CaloRecHitMixer< EcalRecHit >::buildRecHit ( const CaloRecHitMixer_mixedRecHitInfoType< EcalRecHit > &  recHitInfo )

private

Definition at line 34 of file CaloRecHitMixer.cc.

References CaloRecHitMixer_mixedRecHitInfoType< T >::energySum_, CaloRecHitMixer_mixedRecHitInfoType< T >::isRecHit1_, CaloRecHitMixer_mixedRecHitInfoType< T >::isRecHit2_, CaloRecHitMixer_mixedRecHitInfoType< T >::isRecHitSum_, NULL, CaloRecHitMixer_mixedRecHitInfoType< T >::recHit1_, CaloRecHitMixer_mixedRecHitInfoType< T >::recHit2_, and EcalRecHit::setEnergy().

{
  // CV: take status flags and timing information from simulated tau decay products
  //    (suggested by Florian Beaudette)
  const EcalRecHit* recHit_ecal = NULL;
  if      ( recHitInfo.isRecHit1_ ) recHit_ecal = recHitInfo.recHit1_;
  else if ( recHitInfo.isRecHit2_ ) recHit_ecal = recHitInfo.recHit2_;

  assert(recHit_ecal);
  assert(recHitInfo.isRecHitSum_);

  EcalRecHit mergedRecHit(*recHit_ecal);
  mergedRecHit.setEnergy(recHitInfo.energySum_);

  /* TODO Does not make sense
  uint32_t flagBits = 0;
  for ( int flag = 0; flag < 32; ++flag ) {
    if ( recHit_ecal->checkFlag(flag) ) flagBits += (0x1 << flag);
  }
  EcalRecHit mergedRecHit(recHit_ecal->detid(), recHitInfo.energySum_, recHit_ecal->time(), recHit_ecal->flags(), flagBits);
  mergedRecHit.setAux(recHit_ecal->aux());
  */

  return mergedRecHit;
}

template<typename T >

T CaloRecHitMixer< T >::buildRecHit ( const CaloRecHitMixer_mixedRecHitInfoType< T > &  recHitInfo )

private

Definition at line 22 of file CaloRecHitMixer.cc.

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

template<>

HBHERecHit CaloRecHitMixer< HBHERecHit >::buildRecHit ( const CaloRecHitMixer_mixedRecHitInfoType< HBHERecHit > &  recHitInfo )

private

Definition at line 86 of file CaloRecHitMixer.cc.

{
  return buildRecHit_HCAL<HBHERecHit>(recHitInfo);
}

template<>

HORecHit CaloRecHitMixer< HORecHit >::buildRecHit ( const CaloRecHitMixer_mixedRecHitInfoType< HORecHit > &  recHitInfo )

private

Definition at line 92 of file CaloRecHitMixer.cc.

{
  return buildRecHit_HCAL<HORecHit>(recHitInfo);
}

template<>

HFRecHit CaloRecHitMixer< HFRecHit >::buildRecHit ( const CaloRecHitMixer_mixedRecHitInfoType< HFRecHit > &  recHitInfo )

private

Definition at line 98 of file CaloRecHitMixer.cc.

{
  return buildRecHit_HCAL<HFRecHit>(recHitInfo);
}

template<>

CastorRecHit CaloRecHitMixer< CastorRecHit >::buildRecHit ( const CaloRecHitMixer_mixedRecHitInfoType< CastorRecHit > &  recHitInfo )

private

Definition at line 109 of file CaloRecHitMixer.cc.

References CaloRecHit::aux(), CaloRecHit::detid(), CaloRecHitMixer_mixedRecHitInfoType< T >::energySum_, CaloRecHit::flags(), CaloRecHitMixer_mixedRecHitInfoType< T >::isRecHit1_, CaloRecHitMixer_mixedRecHitInfoType< T >::isRecHit2_, CaloRecHitMixer_mixedRecHitInfoType< T >::isRecHitSum_, CaloRecHitMixer_mixedRecHitInfoType< T >::recHit1_, CaloRecHitMixer_mixedRecHitInfoType< T >::recHit2_, CaloRecHit::setFlags(), and CaloRecHit::time().

{
  // CV: take status flags and timing information from simulated tau decay products
  //    (suggested by Florian Beaudette)
  const CaloRecHit* recHit = 0;
  if      ( recHitInfo.isRecHit1_ ) recHit = recHitInfo.recHit1_;
  else if ( recHitInfo.isRecHit2_ ) recHit = recHitInfo.recHit2_;
  const CastorRecHit* recHit_castor = static_cast<const CastorRecHit*>(recHit);
  assert(recHit_castor);
  assert(recHitInfo.isRecHitSum_);
  CastorRecHit mergedRecHit(recHit_castor->detid(), recHitInfo.energySum_, recHit_castor->time());
  mergedRecHit.setFlags(recHit_castor->flags());
  mergedRecHit.setAux(recHit_castor->aux());
  return mergedRecHit;
}

template<typename T >

void CaloRecHitMixer< T >::produce ( edm::Event &  evt, const edm::EventSetup &  es  )

privatevirtual

Implements edm::EDProducer.

Definition at line 162 of file CaloRecHitMixer.h.

References edm::HandleBase::clear(), gather_cfg::cout, alignCSCRings::e, edm::Event::getByLabel(), moduleLabel_(), edm::Event::put(), and AlCaHLTBitMon_QueryRunRegistry::string.

{
  if ( verbosity_ ) std::cout << "<CaloRecHitMixer::produce (" << moduleLabel_ << ")>:" << std::endl;
  
  edm::Handle<detIdToFloatMap> energyDepositMapMuPlus;
  evt.getByLabel(srcEnergyDepositMapMuPlus_, energyDepositMapMuPlus);
  edm::Handle<detIdToFloatMap> energyDepositMapMuMinus;
  evt.getByLabel(srcEnergyDepositMapMuMinus_, energyDepositMapMuMinus);

  for ( typename std::vector<todoListEntryType>::const_iterator todoItem = todoList_.begin();
    todoItem != todoList_.end(); ++todoItem ) {
    edm::Handle<RecHitCollection> recHitCollection1;
    evt.getByLabel(todoItem->srcRecHitCollection1_, recHitCollection1);
    edm::Handle<RecHitCollection> recHitCollection2;
    evt.getByLabel(todoItem->srcRecHitCollection2_, recHitCollection2);
    if ( verbosity_ ) {
      std::cout << "recHitCollection(input1 = " << todoItem->srcRecHitCollection1_.label() << ":" << todoItem->srcRecHitCollection1_.instance() << ":" << todoItem->srcRecHitCollection1_.process() << "):" 
        << " #entries = " << recHitCollection1->size() << std::endl;
      std::cout << "recHitCollection(input2 = " << todoItem->srcRecHitCollection2_.label() << ":" << todoItem->srcRecHitCollection2_.instance() << ":" << todoItem->srcRecHitCollection2_.process() << "):" 
        << " #entries = " << recHitCollection2->size() << std::endl;
    }

    mixedRecHitInfos_.clear();
    updateRecHitInfos(*recHitCollection1, 0);
    updateRecHitInfos(*recHitCollection2, 1);
    
    std::auto_ptr<RecHitCollection> recHitCollection_output(new RecHitCollection());
    std::auto_ptr<double> removedEnergyMuPlus(new double(0.));
    std::auto_ptr<double> removedEnergyMuMinus(new double(0.));

    double muPlusEnergySum  = 0.;
    double muMinusEnergySum = 0.;

    for ( typename detIdToMixedRecHitInfoMap::iterator mixedRecHitInfo = mixedRecHitInfos_.begin();
      mixedRecHitInfo != mixedRecHitInfos_.end(); ++mixedRecHitInfo ) {
      uint32_t rawDetId = mixedRecHitInfo->second.rawDetId_;

      double muPlusEnergyDeposit  = getCorrection(rawDetId, *energyDepositMapMuPlus);
      double muMinusEnergyDeposit = getCorrection(rawDetId, *energyDepositMapMuMinus);
      double muonEnergyDeposit = muPlusEnergyDeposit + muMinusEnergyDeposit;

      muPlusEnergySum  += muPlusEnergyDeposit;
      muMinusEnergySum += muMinusEnergyDeposit;

      if ( muonEnergyDeposit > 0. ) {
    if ( verbosity_ ) std::cout << "removing muon energy: detId = " << rawDetId << ", subtracted = " << muonEnergyDeposit << std::endl;
    if ( mixedRecHitInfo->second.isRecHit1_ && todoItem->muonEnSutractionMode_ == todoListEntryType::kSubtractFromCollection1BeforeMixing ) {
      if ( todoItem->killNegEnergyBeforeMixing1_ && mixedRecHitInfo->second.energy1_ < muonEnergyDeposit ) {
        if ( verbosity_ ) std::cout << "--> killing recHit1: detId = " << rawDetId << ", energy = " << (mixedRecHitInfo->second.energy1_ - muonEnergyDeposit) << std::endl;
        (*removedEnergyMuPlus) += ((mixedRecHitInfo->second.energy1_/muonEnergyDeposit)*muPlusEnergyDeposit);
        (*removedEnergyMuMinus) += ((mixedRecHitInfo->second.energy1_/muonEnergyDeposit)*muMinusEnergyDeposit);
        mixedRecHitInfo->second.energy1_ = 0.;
        mixedRecHitInfo->second.isRecHit1_ = false;   
      } else {
        (*removedEnergyMuPlus)  += muPlusEnergyDeposit;
        (*removedEnergyMuMinus) += muMinusEnergyDeposit;
        mixedRecHitInfo->second.energy1_ -= muonEnergyDeposit;    
      }
    }
    if ( mixedRecHitInfo->second.isRecHit2_ && todoItem->muonEnSutractionMode_ == todoListEntryType::kSubtractFromCollection2BeforeMixing ) {
      if ( todoItem->killNegEnergyBeforeMixing2_ && mixedRecHitInfo->second.energy2_ < muonEnergyDeposit ) {
        if ( verbosity_ ) std::cout << "--> killing recHit2: detId = " << rawDetId << ", energy = " << (mixedRecHitInfo->second.energy2_ - muonEnergyDeposit) << std::endl;
        (*removedEnergyMuPlus)  += ((mixedRecHitInfo->second.energy2_/muonEnergyDeposit)*muPlusEnergyDeposit);
        (*removedEnergyMuMinus) += ((mixedRecHitInfo->second.energy2_/muonEnergyDeposit)*muMinusEnergyDeposit);
        mixedRecHitInfo->second.energy2_ = 0.;
        mixedRecHitInfo->second.isRecHit2_ = false;
      } else {
        (*removedEnergyMuPlus)  += muPlusEnergyDeposit;
        (*removedEnergyMuMinus) += muMinusEnergyDeposit;
        mixedRecHitInfo->second.energy2_ -= muonEnergyDeposit;    
      }
    }
      }
      
      mixedRecHitInfo->second.energySum_ = 0.;
      mixedRecHitInfo->second.isRecHitSum_ = false;
      if ( mixedRecHitInfo->second.isRecHit1_ ) {
    mixedRecHitInfo->second.energySum_ += mixedRecHitInfo->second.energy1_;
    mixedRecHitInfo->second.isRecHitSum_ = true;
      }
      if ( mixedRecHitInfo->second.isRecHit2_ ) {
    mixedRecHitInfo->second.energySum_ += mixedRecHitInfo->second.energy2_;
    mixedRecHitInfo->second.isRecHitSum_ = true;
      }
      if ( muonEnergyDeposit > 0. ) {
    if ( mixedRecHitInfo->second.isRecHitSum_ && todoItem->muonEnSutractionMode_ == todoListEntryType::kSubtractAfterMixing ) {
      if ( todoItem->killNegEnergyAfterMixing_ && mixedRecHitInfo->second.energySum_ < muonEnergyDeposit ) {
        if ( verbosity_ ) std::cout << "--> killing recHitSum: detId = " << rawDetId << ", energy = " << (mixedRecHitInfo->second.energySum_ - muonEnergyDeposit) << std::endl;
        (*removedEnergyMuPlus)  += ((mixedRecHitInfo->second.energySum_/muonEnergyDeposit)*muPlusEnergyDeposit);
        (*removedEnergyMuMinus) += ((mixedRecHitInfo->second.energySum_/muonEnergyDeposit)*muMinusEnergyDeposit);
        mixedRecHitInfo->second.energySum_ = 0.;
        mixedRecHitInfo->second.isRecHitSum_ = false;
      } else {
        (*removedEnergyMuPlus)  += muPlusEnergyDeposit;
        (*removedEnergyMuMinus) += muMinusEnergyDeposit;
        mixedRecHitInfo->second.energySum_ -= muonEnergyDeposit;      
      }
    }
      }

      if ( mixedRecHitInfo->second.isRecHitSum_ ) {
    if ( verbosity_ ) {
      if ( muonEnergyDeposit > 1.e-3 ) std::cout << "--> adding recHitSum (cleaned): detId = " << rawDetId << ", energy = " << mixedRecHitInfo->second.energySum_ << std::endl;
      else std::cout << "--> adding recHitSum (uncleaned): detId = " << rawDetId << ", energy = " << mixedRecHitInfo->second.energySum_ << std::endl;
    }
    recHitCollection_output->push_back(buildRecHit(mixedRecHitInfo->second));
      }
    }

    if ( verbosity_ ) {
      std::cout << " mu+: sum(EnergyDeposits) = " << muPlusEnergySum << " (removed = " << (*removedEnergyMuPlus) << ")" << std::endl;
      std::cout << " mu-: sum(EnergyDeposits) = " << muMinusEnergySum << " (removed = " << (*removedEnergyMuMinus) << ")" << std::endl;
      std::cout << "recHitCollection(output = " << moduleLabel_ << ":" << todoItem->srcRecHitCollection1_.instance() << "): #entries = " << recHitCollection_output->size() << std::endl;
    }    

    std::string instanceLabel = todoItem->srcRecHitCollection1_.instance();
    evt.put(recHitCollection_output, instanceLabel);
    std::string instanceLabel_removedEnergyMuMinus = "removedEnergyMuMinus";
    if ( instanceLabel != "" ) instanceLabel_removedEnergyMuMinus.append("#").append(instanceLabel);
    evt.put(removedEnergyMuMinus, instanceLabel_removedEnergyMuMinus.data());
    std::string instanceLabel_removedEnergyMuPlus = "removedEnergyMuPlus";
    if ( instanceLabel != "" ) instanceLabel_removedEnergyMuPlus.append("#").append(instanceLabel);
    evt.put(removedEnergyMuPlus, instanceLabel_removedEnergyMuPlus.data());
  }
}

template<typename T >

void CaloRecHitMixer< T >::updateRecHitInfos ( const RecHitCollection &  recHitCollection, int  idx  )

private

Definition at line 289 of file CaloRecHitMixer.h.

References edm::SortedCollection< T, SORT >::begin(), gather_cfg::cout, edm::SortedCollection< T, SORT >::end(), CaloRecHitMixer_mixedRecHitInfoType< T >::energy1_, CaloRecHitMixer_mixedRecHitInfoType< T >::energy2_, CaloRecHitMixer_mixedRecHitInfoType< T >::energySum_, CaloRecHitMixer_mixedRecHitInfoType< T >::isRecHit1_, CaloRecHitMixer_mixedRecHitInfoType< T >::isRecHit2_, CaloRecHitMixer_mixedRecHitInfoType< T >::isRecHitSum_, CaloRecHitMixer_mixedRecHitInfoType< T >::rawDetId_, CaloRecHitMixer_mixedRecHitInfoType< T >::recHit1_, and CaloRecHitMixer_mixedRecHitInfoType< T >::recHit2_.

{
  for ( typename RecHitCollection::const_iterator recHit = recHitCollection.begin();
    recHit != recHitCollection.end(); ++recHit ) {
    uint32_t rawDetId = recHit->detid().rawId();

    bool isNewRecHit = (mixedRecHitInfos_.find(rawDetId) == mixedRecHitInfos_.end());
    if ( isNewRecHit ) {
      CaloRecHitMixer_mixedRecHitInfoType<T> mixedRecHitInfo;
      mixedRecHitInfo.rawDetId_    = rawDetId;
      mixedRecHitInfo.energy1_     = 0.;
      mixedRecHitInfo.isRecHit1_   = false;
      mixedRecHitInfo.recHit1_     = 0;
      mixedRecHitInfo.energy2_     = 0.;
      mixedRecHitInfo.isRecHit2_   = false;
      mixedRecHitInfo.recHit2_     = 0;
      mixedRecHitInfo.energySum_   = 0.;
      mixedRecHitInfo.isRecHitSum_ = false;
      mixedRecHitInfos_.insert(std::pair<uint32_t, CaloRecHitMixer_mixedRecHitInfoType<T> >(rawDetId, mixedRecHitInfo));
    } 
    
    typename detIdToMixedRecHitInfoMap::iterator mixedRecHitInfo = mixedRecHitInfos_.find(rawDetId);
    assert(mixedRecHitInfo != mixedRecHitInfos_.end());

    if ( verbosity_ ) {
      if ( isNewRecHit ) std::cout << "creating new recHit: detId = " << rawDetId << ", energy = " << recHit->energy() << std::endl;
      else std::cout << "merging recHits: detId = " << rawDetId << ", total energy = " << (mixedRecHitInfo->second.energy1_ + mixedRecHitInfo->second.energy2_) 
             << " (added = " << recHit->energy() << ")" << std::endl;
    }

    if ( idx == 0 ) {
      mixedRecHitInfo->second.energy1_   = recHit->energy();
      mixedRecHitInfo->second.isRecHit1_ = true;
      mixedRecHitInfo->second.recHit1_   = &(*recHit);
    } else if ( idx == 1 ) {
      mixedRecHitInfo->second.energy2_   = recHit->energy();
      mixedRecHitInfo->second.isRecHit2_ = true;
      mixedRecHitInfo->second.recHit2_   = &(*recHit);
    } else assert(0);
  }
}

Member Data Documentation

template<typename T >

detIdToMixedRecHitInfoMap CaloRecHitMixer< T >::mixedRecHitInfos_

private

Definition at line 73 of file CaloRecHitMixer.h.

template<typename T >

std::string CaloRecHitMixer< T >::moduleLabel_

private

Definition at line 56 of file CaloRecHitMixer.h.

Referenced by Mixins._TypedParameterizable::insertInto(), Modules.ESSource::nameInProcessDesc_(), and Modules.ESProducer::nameInProcessDesc_().

template<typename T >

edm::InputTag CaloRecHitMixer< T >::srcEnergyDepositMapMuMinus_

private

Definition at line 79 of file CaloRecHitMixer.h.

template<typename T >

edm::InputTag CaloRecHitMixer< T >::srcEnergyDepositMapMuPlus_

private

Definition at line 78 of file CaloRecHitMixer.h.

template<typename T >

std::vector<todoListEntryType> CaloRecHitMixer< T >::todoList_

private

Definition at line 68 of file CaloRecHitMixer.h.

Referenced by CaloRecHitMixer< T >::CaloRecHitMixer().

template<typename T >

int CaloRecHitMixer< T >::typeEnergyDepositMap_

private

Definition at line 81 of file CaloRecHitMixer.h.

Referenced by CaloRecHitMixer< T >::CaloRecHitMixer().

template<typename T >

int CaloRecHitMixer< T >::verbosity_

private

Definition at line 85 of file CaloRecHitMixer.h.

Referenced by CaloRecHitMixer< T >::CaloRecHitMixer().