Inheritance diagram for sistrip::FEDEmulatorModule:

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

	~FEDEmulatorModule ()

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

void	resolvePutIndicies (BranchType iBranchType, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

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

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

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

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

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

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

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

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
virtual void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
std::unique_ptr< SiStripRawProcessingAlgorithms >	algorithms_
	object for zero-suppression More...

bool	byModule_

sistrip::FEDEmulator	fedEmulator_

edm::InputTag	spyReorderedDigisTag_

edm::EDGetTokenT< edm::DetSetVector< SiStripRawDigi > >	spyReorderedDigisToken_

edm::InputTag	spyVirginRawDigisTag_

edm::EDGetTokenT< edm::DetSetVector< SiStripRawDigi > >	spyVirginRawDigisToken_

SpyUtilities	utility_

Static Private Attributes
static const char *	messageLabel_ = "SiStripFEDEmulatorModule"

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	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::EDProducer
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 58 of file SiStripFEDEmulatorModule.cc.

Constructor & Destructor Documentation

sistrip::FEDEmulatorModule::FEDEmulatorModule ( const edm::ParameterSet & iConfig )

explicit

Definition at line 101 of file SiStripFEDEmulatorModule.cc.

References byModule_, fedEmulator_, sistrip::FEDEmulator::initialise(), spyReorderedDigisTag_, spyReorderedDigisToken_, spyVirginRawDigisTag_, and spyVirginRawDigisToken_.

                                                                     : 
     spyReorderedDigisTag_(iConfig.getParameter<edm::InputTag>("SpyReorderedDigisTag")),
     spyVirginRawDigisTag_(iConfig.getParameter<edm::InputTag>("SpyVirginRawDigisTag")),
     byModule_(iConfig.getParameter<bool>("ByModule")),
     algorithms_(SiStripRawProcessingFactory::create(iConfig.getParameter<edm::ParameterSet>("Algorithms"))) 
   {
 
     spyReorderedDigisToken_ = consumes<edm::DetSetVector<SiStripRawDigi> >(spyReorderedDigisTag_);
     spyVirginRawDigisToken_ = consumes<edm::DetSetVector<SiStripRawDigi> >(spyVirginRawDigisTag_);
 
     fedEmulator_.initialise(byModule_);
 
     if (!byModule_) { //if not by module
       //the medians will be produced by fed id/channel
       produces<std::map<uint32_t,std::vector<uint32_t> > >("Medians");
       produces<edm::DetSetVector<SiStripRawDigi> >("PedestalsOrdered");
       produces<edm::DetSetVector<SiStripProcessedRawDigi> >("NoisesOrdered");
       produces<edm::DetSetVector<SiStripRawDigi> >("PedSubtrDigisOrdered");
       produces<edm::DetSetVector<SiStripRawDigi> >("CMSubtrDigisOrdered");
     }
     else { //by module
       produces<edm::DetSetVector<SiStripRawDigi> >("ModulePedestals");
       produces<edm::DetSetVector<SiStripProcessedRawDigi> >("ModuleNoises");
       produces<edm::DetSetVector<SiStripRawDigi> >("PedSubtrModuleDigis");
       produces<std::map<uint32_t,std::vector<uint32_t> > >("ModuleMedians");
       produces<edm::DetSetVector<SiStripRawDigi> >("CMSubtrModuleDigis");
       produces<edm::DetSetVector<SiStripDigi> >("ZSModuleDigis");
     }//end of by module check
 
   }//end of FEDEmulatorModule constructor

sistrip::FEDEmulatorModule::~FEDEmulatorModule ( )

Definition at line 132 of file SiStripFEDEmulatorModule.cc.

133 {

134 }

Member Function Documentation

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

overrideprivatevirtual

Definition at line 138 of file SiStripFEDEmulatorModule.cc.

References algorithms_, FedChannelConnection::apvPairNumber(), edm::DetSetVector< T >::begin(), byModule_, gather_cfg::cout, FedChannelConnection::detId(), MillePedeFileConverter_cfg::e, edm::DetSetVector< T >::end(), SiStripFedCabling::fedConnection(), fedEmulator_, sistrip::SpyUtilities::fedIndex(), edm::Event::getByToken(), sistrip::SpyUtilities::getCabling(), sistrip::SpyUtilities::getNoiseHandle(), sistrip::SpyUtilities::getPedestalHandle(), sistrip::FEDEmulator::initialiseModule(), genParticles_cff::map, eostools::move(), FedChannelConnection::nApvPairs(), edm::Handle< T >::product(), edm::Event::put(), sistrip::FEDEmulator::retrieveNoises(), sistrip::FEDEmulator::retrievePedestals(), edm::DetSet< T >::size(), edm::DetSetVector< T >::size(), spyReorderedDigisToken_, spyVirginRawDigisToken_, sistrip::STRIPS_PER_FEDCH, sistrip::FEDEmulator::subtractCM(), sistrip::FEDEmulator::subtractPedestals(), utility_, cms::Exception::what(), and sistrip::FEDEmulator::zeroSuppress().

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

   {
     //update cabling and pedestals
     const SiStripFedCabling* lCabling = utility_.getCabling( iSetup );
     edm::ESHandle<SiStripPedestals> lPedsHandle = utility_.getPedestalHandle(iSetup);
     edm::ESHandle<SiStripNoises> lNoiseHandle = utility_.getNoiseHandle(iSetup);
   
     //initialise the algorithms object for the zero suppression
     algorithms_->initialize(iSetup);
 
     //retrieve the digis
     edm::Handle<edm::DetSetVector<SiStripRawDigi> > lDigisHandle;
     try { //to get the digis from the event
       if (!byModule_) {
     iEvent.getByToken(spyReorderedDigisToken_, lDigisHandle);
       }
       else { //digis supplied by module
     iEvent.getByToken(spyVirginRawDigisToken_, lDigisHandle);
       }//end of by module check
     } catch (const cms::Exception& e) {
       std::cout << e.what() ;
       return;
     } //end of get digis try
 
     const edm::DetSetVector<SiStripRawDigi> * lInputDigis = lDigisHandle.product();
 
     unsigned int lNDigis = lInputDigis->size();
 
     //define output containers
     //reserve space, will push_back elements
     std::vector<edm::DetSetVector<SiStripRawDigi>::detset > pedsData;
     pedsData.reserve(lNDigis);
     std::vector<edm::DetSetVector<SiStripProcessedRawDigi>::detset > noiseData;
     noiseData.reserve(lNDigis);
     std::vector<edm::DetSetVector<SiStripRawDigi>::detset > pedSubtrData;
     pedSubtrData.reserve(lNDigis);
     std::vector<edm::DetSetVector<SiStripRawDigi>::detset > cmSubtrData;
     cmSubtrData.reserve(lNDigis);
     //zero suppressed contained - no fixed size (could be empty) so no need to reserve elements.
     std::vector< edm::DetSet<SiStripDigi> > zsData;
     
     //this is a map: no reserve/resize
     std::map<uint32_t,std::vector<uint32_t> > medsData;
 
     edm::DetSetVector<SiStripRawDigi>::const_iterator inputChannel = lInputDigis->begin();
 
     for ( ; inputChannel!=lInputDigis->end(); ++inputChannel){//loop on input channels
       uint32_t lDetId = inputChannel->detId(); //either fedIndex or detId
 
       pedsData.push_back(    edm::DetSetVector<SiStripRawDigi>::detset(lDetId) );
       noiseData.push_back(   edm::DetSetVector<SiStripProcessedRawDigi>::detset(lDetId) );
       pedSubtrData.push_back(edm::DetSetVector<SiStripRawDigi>::detset(lDetId) );
       cmSubtrData.push_back( edm::DetSetVector<SiStripRawDigi>::detset(lDetId) );
 
       unsigned int lNStrips = inputChannel->size();
 
       //define output digi containers
       std::vector<SiStripRawDigi>& pedsDetSetData = pedsData.back().data;
       pedsDetSetData.reserve(lNStrips);
       std::vector<SiStripProcessedRawDigi>& noiseDetSetData = noiseData.back().data;
       noiseDetSetData.reserve(lNStrips);
       std::vector<SiStripRawDigi>& pedSubtrDetSetData = pedSubtrData.back().data;
       pedSubtrDetSetData.reserve(lNStrips);
       std::vector<SiStripRawDigi>& cmSubtrDetSetData = cmSubtrData.back().data;
       cmSubtrDetSetData.reserve(lNStrips);
       //zero suppressed - slightly different procedure as not fixed size
       edm::DetSet<SiStripDigi> zsDetSetData(lDetId);
       
       //determine the number of APV pairs in the channel
       uint32_t lNPairs = static_cast<uint32_t>(lNStrips*1./sistrip::STRIPS_PER_FEDCH);
       uint32_t lPair = 0;
       
       std::vector<uint32_t> medsDetSetData;
       medsDetSetData.reserve(lNPairs*2); //2*number of pairs per module. If not by module, lNPairs = 1...
       
       if (!byModule_) { //the input is not stored by module
     //need to retrieve the proper detId from cabling
     uint16_t lFedId = 0;
     uint16_t lFedChannel = 0;
     sistrip::SpyUtilities::fedIndex(lDetId, lFedId, lFedChannel);
             
     const FedChannelConnection & lConnection = lCabling->fedConnection(lFedId,lFedChannel);
     lDetId = lConnection.detId();
     lNPairs = lConnection.nApvPairs();
     lPair = lConnection.apvPairNumber();
       }//end of by module check
 
       fedEmulator_.initialiseModule(lDetId,lNPairs,lPair);
 
       //get the pedestal values
       //stored by module in the database
       fedEmulator_.retrievePedestals(lPedsHandle);
       fedEmulator_.retrieveNoises(lNoiseHandle);
       
       //last option: fill medians from these ped subtr data
       //if want something else, need to call a method to fill
       //the data member medians_ of the class fedEmulator.
       fedEmulator_.subtractPedestals(inputChannel,
                      pedsDetSetData,
                      noiseDetSetData,
                      pedSubtrDetSetData,
                      medsDetSetData,
                      true);
       
       fedEmulator_.subtractCM(pedSubtrDetSetData,cmSubtrDetSetData);
 
       //fill the median map
       medsData[inputChannel->detId()] = medsDetSetData;
 
       //zero suppress the digis
       fedEmulator_.zeroSuppress(cmSubtrDetSetData, zsDetSetData, algorithms_);
       if (zsDetSetData.size()) zsData.push_back( zsDetSetData );
       
     }//loop on input channels
 
 
     std::unique_ptr<edm::DetSetVector<SiStripRawDigi> > lPeds(new edm::DetSetVector<SiStripRawDigi>(pedsData,true));
     std::unique_ptr<edm::DetSetVector<SiStripProcessedRawDigi> > lNoises(new edm::DetSetVector<SiStripProcessedRawDigi>(noiseData,true));
 
     std::unique_ptr<edm::DetSetVector<SiStripRawDigi> > lOutputPedSubtr(new edm::DetSetVector<SiStripRawDigi>(pedSubtrData,true));
 
     std::unique_ptr<edm::DetSetVector<SiStripRawDigi> > lOutputCMSubtr(new edm::DetSetVector<SiStripRawDigi>(cmSubtrData,true));
 
     std::unique_ptr<std::map<uint32_t,std::vector<uint32_t> > > lMedians(new std::map<uint32_t,std::vector<uint32_t> >(medsData));
   
     //zero suppressed digis
     std::unique_ptr< edm::DetSetVector<SiStripDigi> > lOutputZS(new edm::DetSetVector<SiStripDigi>(zsData));
     
     if (!byModule_) {
       iEvent.put(std::move(lMedians),"Medians");
       iEvent.put(std::move(lPeds),"PedestalsOrdered");
       iEvent.put(std::move(lNoises),"NoisesOrdered");
       iEvent.put(std::move(lOutputPedSubtr),"PedSubtrDigisOrdered");
       iEvent.put(std::move(lOutputCMSubtr),"CMSubtrDigisOrdered");
     }
     else {
       iEvent.put(std::move(lPeds),"ModulePedestals");
       iEvent.put(std::move(lNoises),"ModuleNoises");
       iEvent.put(std::move(lOutputPedSubtr),"PedSubtrModuleDigis");
       iEvent.put(std::move(lMedians),"ModuleMedians");
       iEvent.put(std::move(lOutputCMSubtr),"CMSubtrModuleDigis");
       iEvent.put(std::move(lOutputZS),"ZSModuleDigis");
     }
 
   }//produce method