#include <CaloRecHitCopy.h>

Inheritance diagram for CaloRecHitCopy:

Public Member Functions
	CaloRecHitCopy (edm::ParameterSet const &p)

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

virtual	~CaloRecHitCopy ()

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 Attributes
edm::EDGetTokenT < EBRecHitCollection >	theEBRecHitCollectionToken

edm::EDGetTokenT < EERecHitCollection >	theEERecHitCollectionToken

edm::EDGetTokenT < ESRecHitCollection >	theESRecHitCollectionToken

edm::EDGetTokenT < HBHERecHitCollection >	theHBHERecHitCollectionToken

edm::EDGetTokenT < HFRecHitCollection >	theHFRecHitCollectionToken

edm::EDGetTokenT < HORecHitCollection >	theHORecHitCollectionToken

std::vector< edm::InputTag >	theInputRecHitCollections

std::vector< unsigned int >	theInputRecHitCollectionTypes

std::vector< std::string >	theOutputRecHitCollections

std::vector< bool >	theOutputRecHitInstances

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

Definition at line 20 of file CaloRecHitCopy.h.

Constructor & Destructor Documentation

CaloRecHitCopy::CaloRecHitCopy ( edm::ParameterSet const & p )

explicit

Definition at line 10 of file CaloRecHitCopy.cc.

References edm::ParameterSet::getParameter(), input, theEBRecHitCollectionToken, theEERecHitCollectionToken, theESRecHitCollectionToken, theHBHERecHitCollectionToken, theHFRecHitCollectionToken, theHORecHitCollectionToken, theInputRecHitCollections, theInputRecHitCollectionTypes, theOutputRecHitCollections, and theOutputRecHitInstances.

 {    
 
   theInputRecHitCollectionTypes = p.getParameter<std::vector<unsigned> >("InputRecHitCollectionTypes");
   theInputRecHitCollections = p.getParameter<std::vector<edm::InputTag> >("InputRecHitCollections");
   theOutputRecHitCollections = p.getParameter<std::vector<std::string> >("OutputRecHitCollections");
 
   theOutputRecHitInstances.resize(theInputRecHitCollectionTypes.size());
   
   for ( unsigned input=0; input<theInputRecHitCollectionTypes.size(); ++input ) { 
 
     theOutputRecHitInstances[input] = 
       theOutputRecHitCollections[input] == "none" ?
       false : true;
 
     switch ( theInputRecHitCollectionTypes[input] ) { 
       
     case 1: 
       {
     //Preshower
     theESRecHitCollectionToken = consumes<ESRecHitCollection>(theInputRecHitCollections[input]);
     if ( !theOutputRecHitInstances[input] ) 
       produces<ESRecHitCollection>();
     else
       produces<ESRecHitCollection>(theOutputRecHitCollections[input]);
       }
       break;
       
     case 2:
       { 
     //Ecal Barrel 
     theEBRecHitCollectionToken = consumes<EBRecHitCollection>(theInputRecHitCollections[input]);
     if ( !theOutputRecHitInstances[input] ) 
       produces<EBRecHitCollection>();
     else
       produces<EBRecHitCollection>(theOutputRecHitCollections[input]);
       }
       break;
       
     case 3:
       { 
     //EcalEndcap
     theEERecHitCollectionToken = consumes<EERecHitCollection>(theInputRecHitCollections[input]);
     if ( !theOutputRecHitInstances[input] ) 
       produces<EERecHitCollection>();
     else
       produces<EERecHitCollection>(theOutputRecHitCollections[input]);
       }
       break;
       
     case 4:
       { 
     //HCAL
     theHBHERecHitCollectionToken = consumes<HBHERecHitCollection>(theInputRecHitCollections[input]);
     if ( !theOutputRecHitInstances[input] ) 
       produces<HBHERecHitCollection>();
     else
       produces<HBHERecHitCollection>(theOutputRecHitCollections[input]);
       }
       break;
       
     case 5:
       { 
     //HO
     theHORecHitCollectionToken = consumes<HORecHitCollection>(theInputRecHitCollections[input]);
     if ( !theOutputRecHitInstances[input] ) 
       produces<HORecHitCollection>();
     else
       produces<HORecHitCollection>(theOutputRecHitCollections[input]);
       }
       break;
       
     case 6:
       { 
     //HF
     theHFRecHitCollectionToken = consumes<HFRecHitCollection>(theInputRecHitCollections[input]);
     if ( !theOutputRecHitInstances[input] ) 
       produces<HFRecHitCollection>();
     else
       produces<HFRecHitCollection>(theOutputRecHitCollections[input]);
       }
       break;
       
     default:
       // Should not happen
       break;
       
     }
     
   }
   
 
 }

CaloRecHitCopy::~CaloRecHitCopy ( )

virtual

Definition at line 105 of file CaloRecHitCopy.cc.

105 { }

Member Function Documentation

void CaloRecHitCopy::produce	(	edm::Event &	e,
		const edm::EventSetup &	c
	)

overridevirtual

Implements edm::EDProducer.

Definition at line 108 of file CaloRecHitCopy.cc.

References egHLT::errCodes::EBRecHits, egHLT::errCodes::EERecHits, edm::Event::getByToken(), egHLT::errCodes::HBHERecHits, egHLT::errCodes::HFRecHits, input, edm::Event::put(), theEBRecHitCollectionToken, theEERecHitCollectionToken, theESRecHitCollectionToken, theHBHERecHitCollectionToken, theHFRecHitCollectionToken, theHORecHitCollectionToken, theInputRecHitCollectionTypes, theOutputRecHitCollections, and theOutputRecHitInstances.

Referenced by JSONExport.JsonExport::export(), HTMLExport.HTMLExport::export(), and HTMLExport.HTMLExportStatic::export().

 {
 
 
   for ( unsigned input=0; input<theInputRecHitCollectionTypes.size(); ++input ) { 
 
     switch ( theInputRecHitCollectionTypes[input] ) { 
       
     case 1: 
       {
     //Preshower
     std::auto_ptr< ESRecHitCollection > copiedESRecHitCollection( new ESRecHitCollection );
     edm::Handle<ESRecHitCollection> ESRecHits;
     iEvent.getByToken(theESRecHitCollectionToken,ESRecHits);
     ESRecHitCollection::const_iterator itES = ESRecHits->begin();
     ESRecHitCollection::const_iterator lastES = ESRecHits->end();
     // saves a bit of CPU
     copiedESRecHitCollection->reserve(ESRecHits->size());
     for ( ; itES!=lastES; ++itES++ ) {
       EcalRecHit aHit(*itES);
       copiedESRecHitCollection->push_back(aHit);
     }
     if ( !theOutputRecHitInstances[input] ) 
       iEvent.put(copiedESRecHitCollection);
     else
       iEvent.put(copiedESRecHitCollection,theOutputRecHitCollections[input]);
       }
       break;
       
     case 2: 
       {
     //Ecal Barrel 
     std::auto_ptr< EBRecHitCollection > copiedEBRecHitCollection( new EBRecHitCollection );
     edm::Handle<EBRecHitCollection> EBRecHits;
     iEvent.getByToken(theEBRecHitCollectionToken,EBRecHits);
     EBRecHitCollection::const_iterator itEB = EBRecHits->begin();
     EBRecHitCollection::const_iterator lastEB = EBRecHits->end();
     //saves a bit of CPU
     copiedEBRecHitCollection->reserve(EBRecHits->size());
 
     for ( ; itEB!=lastEB; ++itEB++ ) {
       EcalRecHit aHit(*itEB);
       copiedEBRecHitCollection->push_back(aHit);
     }
     if ( !theOutputRecHitInstances[input] ) 
       iEvent.put(copiedEBRecHitCollection);
     else
       iEvent.put(copiedEBRecHitCollection,theOutputRecHitCollections[input]);
       }
       break;
       
     case 3:
       {
     //EcalEndcap
     std::auto_ptr< EERecHitCollection > copiedEERecHitCollection( new EERecHitCollection );
     edm::Handle<EERecHitCollection> EERecHits;
     iEvent.getByToken(theEERecHitCollectionToken,EERecHits);
     EERecHitCollection::const_iterator itEE = EERecHits->begin();
     EERecHitCollection::const_iterator lastEE = EERecHits->end();
     //saves a bit of CPU
     copiedEERecHitCollection->reserve(EERecHits->size());
 
     for ( ; itEE!=lastEE; ++itEE++ ) {
       EcalRecHit aHit(*itEE);
       copiedEERecHitCollection->push_back(aHit);
     }
     if ( !theOutputRecHitInstances[input] ) 
       iEvent.put(copiedEERecHitCollection);
     else
       iEvent.put(copiedEERecHitCollection,theOutputRecHitCollections[input]);
       }
       break;
       
     case 4:
       {
     //HCAL
     std::auto_ptr< HBHERecHitCollection > copiedHBHERecHitCollection( new HBHERecHitCollection );
     edm::Handle<HBHERecHitCollection> HBHERecHits;
     iEvent.getByToken(theHBHERecHitCollectionToken,HBHERecHits);
     HBHERecHitCollection::const_iterator itHBHE = HBHERecHits->begin();
     HBHERecHitCollection::const_iterator lastHBHE = HBHERecHits->end();
     //saves a bit of CPU
     copiedHBHERecHitCollection->reserve(HBHERecHits->size());
 
     for ( ; itHBHE!=lastHBHE; ++itHBHE++ ) {
       HBHERecHit aHit(*itHBHE);
       copiedHBHERecHitCollection->push_back(aHit);
     }
     if ( !theOutputRecHitInstances[input] ) 
       iEvent.put(copiedHBHERecHitCollection);
     else
       iEvent.put(copiedHBHERecHitCollection,theOutputRecHitCollections[input]);
       }
       break;
       
     case 5:
       {
     //HO
     std::auto_ptr< HORecHitCollection > copiedHORecHitCollection( new HORecHitCollection );
     edm::Handle<HORecHitCollection> HORecHits;
     iEvent.getByToken(theHORecHitCollectionToken,HORecHits);
     HORecHitCollection::const_iterator itHO = HORecHits->begin();
     HORecHitCollection::const_iterator lastHO = HORecHits->end();
     //saves a bit of CPU
     copiedHORecHitCollection->reserve(HORecHits->size());
 
     for ( ; itHO!=lastHO; ++itHO++ ) {
       HORecHit aHit(*itHO);
       copiedHORecHitCollection->push_back(aHit);
     }
     if ( !theOutputRecHitInstances[input] ) 
       iEvent.put(copiedHORecHitCollection);
     else
       iEvent.put(copiedHORecHitCollection,theOutputRecHitCollections[input]);
       }
       break;
       
     case 6:
       {
     //HF
     std::auto_ptr< HFRecHitCollection > copiedHFRecHitCollection( new HFRecHitCollection );
     edm::Handle<HFRecHitCollection> HFRecHits;
     iEvent.getByToken(theHFRecHitCollectionToken,HFRecHits);
     HFRecHitCollection::const_iterator itHF = HFRecHits->begin();
     HFRecHitCollection::const_iterator lastHF = HFRecHits->end();
     //saves a bit of CPU
     copiedHFRecHitCollection->reserve(HFRecHits->size());
     
     for ( ; itHF!=lastHF; ++itHF++ ) {
       HFRecHit aHit(*itHF);
       copiedHFRecHitCollection->push_back(aHit);
     }
     if ( !theOutputRecHitInstances[input] ) 
       iEvent.put(copiedHFRecHitCollection);
     else
       iEvent.put(copiedHFRecHitCollection,theOutputRecHitCollections[input]);
       }
       break;
       
     default:
       // Should not happen
       break;
       
     }
     
   }
 
 }