#include <SelectedElectronFEDListProducer.h>

Inheritance diagram for SelectedElectronFEDListProducer< TEle, TCand >:

Public Member Functions
void	pixelFedDump (std::vector< PixelModule >::const_iterator &itDn, std::vector< PixelModule >::const_iterator &itUp, const PixelRegion &region)

	SelectedElectronFEDListProducer (const edm::ParameterSet &)
	Producer constructor. More...

	~SelectedElectronFEDListProducer () override

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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Protected Member Functions
virtual void	beginJob ()

virtual void	endJob ()

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

Private Types
typedef std::vector< TCand >	TCandColl

typedef std::vector< TEle >	TEleColl

Private Attributes
std::vector< int >	addThisSelectedFEDs_

math::XYZVector	beamSpotPosition_

edm::InputTag	beamSpotTag_

edm::EDGetTokenT< reco::BeamSpot >	beamSpotToken_

double	dEtaPixelRegion_

double	dPhiPixelRegion_

double	dRHcalRegion_

double	dRStripRegion_

bool	dumpAllEcalFed_

bool	dumpAllHCALFed_

bool	dumpAllTrackerFed_

bool	dumpSelectedEcalFed_

bool	dumpSelectedHCALFed_

bool	dumpSelectedSiPixelFed_

bool	dumpSelectedSiStripFed_

const EcalElectronicsMapping *	EcalMapping_

std::vector< edm::InputTag >	electronTags_

std::vector< edm::EDGetTokenT< TEleColl > >	electronToken_

int	ES_fedId_ [2][2][40][40]

edm::FileInPath	ESLookupTable_

std::vector< uint32_t >	fedList_

const CaloGeometry *	GeometryCalo_

const CaloSubdetectorGeometry *	GeometryES_

edm::InputTag	HBHERecHitTag_

edm::EDGetTokenT< HBHERecHitCollection >	hbheRecHitToken_

const HcalElectronicsMap *	HcalReadoutMap_

std::vector< int >	isGsfElectronCollection_

double	maxZPixelRegion_

std::string	outputLabelModule_

std::unique_ptr< SiPixelFedCablingTree >	PixelCabling_

std::vector< PixelModule >	pixelModuleVector_

edm::InputTag	rawDataTag_

edm::EDGetTokenT< FEDRawDataCollection >	rawDataToken_

std::vector< edm::InputTag >	recoEcalCandidateTags_

std::vector< edm::EDGetTokenT< trigger::TriggerFilterObjectWithRefs > >	recoEcalCandidateToken_

std::pair< double, double >	regionDimension_

const SiStripRegionCabling *	StripRegionCabling_

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

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

template<typename TEle, typename TCand>
class SelectedElectronFEDListProducer< TEle, TCand >

Definition at line 76 of file SelectedElectronFEDListProducer.h.

Member Typedef Documentation

◆ TCandColl

template<typename TEle , typename TCand >

typedef std::vector<TCand> SelectedElectronFEDListProducer< TEle, TCand >::TCandColl

private

Definition at line 90 of file SelectedElectronFEDListProducer.h.

◆ TEleColl

template<typename TEle , typename TCand >

typedef std::vector<TEle> SelectedElectronFEDListProducer< TEle, TCand >::TEleColl

private

Definition at line 89 of file SelectedElectronFEDListProducer.h.

Constructor & Destructor Documentation

◆ SelectedElectronFEDListProducer()

template<typename TEle , typename TCand >

SelectedElectronFEDListProducer< TEle, TCand >::SelectedElectronFEDListProducer ( const edm::ParameterSet & iConfig )

explicit

Producer constructor.

Definition at line 70 of file SelectedElectronFEDListProducer.cc.

                                                                                                             {
   // input electron collection Tag
   if (iConfig.existsAs<std::vector<edm::InputTag>>("electronTags")) {
     electronTags_ = iConfig.getParameter<std::vector<edm::InputTag>>("electronTags");
     if (electronTags_.empty())
       throw cms::Exception("Configuration")
           << "[SelectedElectronFEDListProducer] empty electron collection is given --> at least one \n";
   } else
     throw cms::Exception("Configuration")
         << "[SelectedElectronFEDListProducer] no electron collection are given --> need at least one \n";
  
   // Consumes for the electron collection
   LogDebug("SelectedElectronFEDListProducer") << " Electron Collections" << std::endl;
   for (std::vector<edm::InputTag>::const_iterator itEleTag = electronTags_.begin(); itEleTag != electronTags_.end();
        ++itEleTag) {
     electronToken_.push_back(consumes<TEleColl>(*itEleTag));
     LogDebug("SelectedElectronFEDListProducer") << " Ele collection: " << *(itEleTag) << std::endl;
   }
  
   // input RecoEcalCandidate collection Tag
   if (iConfig.existsAs<std::vector<edm::InputTag>>("recoEcalCandidateTags")) {
     recoEcalCandidateTags_ = iConfig.getParameter<std::vector<edm::InputTag>>("recoEcalCandidateTags");
     if (recoEcalCandidateTags_.empty())
       throw cms::Exception("Configuration") << "[SelectedElectronFEDListProducer] empty ecal candidate collections "
                                                "collection is given --> at least one \n";
   } else
     throw cms::Exception("Configuration") << "[SelectedElectronFEDListProducer] no electron reco ecal candidate "
                                              "collection are given --> need at least one \n";
  
   // Consumes for the recoEcal candidate collection
   for (std::vector<edm::InputTag>::const_iterator itEcalCandTag = recoEcalCandidateTags_.begin();
        itEcalCandTag != recoEcalCandidateTags_.end();
        ++itEcalCandTag) {
     recoEcalCandidateToken_.push_back(consumes<trigger::TriggerFilterObjectWithRefs>(*itEcalCandTag));
     LogDebug("SelectedElectronFEDListProducer") << " Reco ecal candidate collection: " << *(itEcalCandTag) << std::endl;
   }
  
   // list of gsf collections
   if (iConfig.existsAs<std::vector<int>>("isGsfElectronCollection")) {
     isGsfElectronCollection_ = iConfig.getParameter<std::vector<int>>("isGsfElectronCollection");
     if (isGsfElectronCollection_.empty())
       throw cms::Exception("Configuration")
           << "[SelectedElectronFEDListProducer] empty electron flag collection --> at least one \n";
   } else
     throw cms::Exception("Configuration")
         << "[SelectedElectronFEDListProducer] no electron flag are given --> need at least one \n";
  
   if (isGsfElectronCollection_.size() != electronTags_.size() or
       isGsfElectronCollection_.size() != recoEcalCandidateTags_.size())
     throw cms::Exception("Configuration") << "[SelectedElectronFEDListProducer] electron flag , electron collection "
                                              "and reco ecal cand collection must have the same size ! \n";
  
   // take the beam spot Tag
   if (iConfig.existsAs<edm::InputTag>("beamSpot"))
     beamSpotTag_ = iConfig.getParameter<edm::InputTag>("beamSpot");
   else
     beamSpotTag_ = edm::InputTag("hltOnlineBeamSpot");
  
   if (!(beamSpotTag_ == edm::InputTag("")))
     beamSpotToken_ = consumes<reco::BeamSpot>(beamSpotTag_);
  
   LogDebug("SelectedElectronFEDListProducer") << " Beam Spot Tag " << beamSpotTag_ << std::endl;
  
   // take the HBHE recHit Tag
   if (iConfig.existsAs<edm::InputTag>("HBHERecHitTag"))
     HBHERecHitTag_ = iConfig.getParameter<edm::InputTag>("HBHERecHitTag");
   else
     HBHERecHitTag_ = edm::InputTag("hltHbhereco");
  
   if (!(HBHERecHitTag_ == edm::InputTag("")))
     hbheRecHitToken_ = consumes<HBHERecHitCollection>(HBHERecHitTag_);
  
   // raw data collector label
   if (iConfig.existsAs<edm::InputTag>("rawDataTag"))
     rawDataTag_ = iConfig.getParameter<edm::InputTag>("rawDataTag");
   else
     rawDataTag_ = edm::InputTag("rawDataCollector");
  
   if (!(rawDataTag_ == edm::InputTag("")))
     rawDataToken_ = consumes<FEDRawDataCollection>(rawDataTag_);
  
   LogDebug("SelectedElectronFEDListProducer") << " RawDataInput " << rawDataTag_ << std::endl;
  
   // add a set of selected feds
   if (iConfig.existsAs<std::vector<int>>("addThisSelectedFEDs")) {
     addThisSelectedFEDs_ = iConfig.getParameter<std::vector<int>>("addThisSelectedFEDs");
     if (addThisSelectedFEDs_.empty())
       addThisSelectedFEDs_.push_back(-1);
   } else
     addThisSelectedFEDs_.push_back(-1);
  
   std::vector<int>::const_iterator AddFed = addThisSelectedFEDs_.begin();
   for (; AddFed != addThisSelectedFEDs_.end(); ++AddFed)
     LogDebug("SelectedElectronFEDListProducer") << " Additional FED: " << *(AddFed) << std::endl;
  
   // ES look up table path
   if (iConfig.existsAs<std::string>("ESLookupTable"))
     ESLookupTable_ = iConfig.getParameter<edm::FileInPath>("ESLookupTable");
   else
     ESLookupTable_ = edm::FileInPath("EventFilter/ESDigiToRaw/data/ES_lookup_table.dat");
  
   // output model label
   if (iConfig.existsAs<std::string>("outputLabelModule"))
     outputLabelModule_ = iConfig.getParameter<std::string>("outputLabelModule");
   else
     outputLabelModule_ = "streamElectronRawData";
  
   LogDebug("SelectedElectronFEDListProducer") << " Output Label " << outputLabelModule_ << std::endl;
  
   // dR for the strip region
   if (iConfig.existsAs<double>("dRStripRegion"))
     dRStripRegion_ = iConfig.getParameter<double>("dRStripRegion");
   else
     dRStripRegion_ = 0.5;
  
   LogDebug("SelectedElectronFEDListProducer") << " dRStripRegion " << dRStripRegion_ << std::endl;
  
   // dR for the hcal region
   if (iConfig.existsAs<double>("dRHcalRegion"))
     dRHcalRegion_ = iConfig.getParameter<double>("dRHcalRegion");
   else
     dRHcalRegion_ = 0.5;
  
   // dPhi, dEta and maxZ for pixel dump
   if (iConfig.existsAs<double>("dPhiPixelRegion"))
     dPhiPixelRegion_ = iConfig.getParameter<double>("dPhiPixelRegion");
   else
     dPhiPixelRegion_ = 0.5;
  
   if (iConfig.existsAs<double>("dEtaPixelRegion"))
     dEtaPixelRegion_ = iConfig.getParameter<double>("dEtaPixelRegion");
   else
     dEtaPixelRegion_ = 0.5;
  
   if (iConfig.existsAs<double>("maxZPixelRegion"))
     maxZPixelRegion_ = iConfig.getParameter<double>("maxZPixelRegion");
   else
     maxZPixelRegion_ = 24.;
  
   LogDebug("SelectedElectronFEDListProducer")
       << " dPhiPixelRegion " << dPhiPixelRegion_ << " dEtaPixelRegion " << dEtaPixelRegion_ << " MaxZPixelRegion "
       << maxZPixelRegion_ << std::endl;
  
   // bool
   if (iConfig.existsAs<bool>("dumpSelectedEcalFed"))
     dumpSelectedEcalFed_ = iConfig.getParameter<bool>("dumpSelectedEcalFed");
   else
     dumpSelectedEcalFed_ = true;
  
   if (iConfig.existsAs<bool>("dumpSelectedSiStripFed"))
     dumpSelectedSiStripFed_ = iConfig.getParameter<bool>("dumpSelectedSiStripFed");
   else
     dumpSelectedSiStripFed_ = true;
  
   if (iConfig.existsAs<bool>("dumpSelectedSiPixelFed"))
     dumpSelectedSiPixelFed_ = iConfig.getParameter<bool>("dumpSelectedSiPixelFed");
   else
     dumpSelectedSiPixelFed_ = true;
  
   if (iConfig.existsAs<bool>("dumpSelectedHCALFed"))
     dumpSelectedHCALFed_ = iConfig.getParameter<bool>("dumpSelectedHCALFed");
   else
     dumpSelectedHCALFed_ = true;
  
   LogDebug("SelectedElectronFEDListProducer")
       << " DumpEcalFedList set to " << dumpSelectedEcalFed_ << " DumpSelectedSiStripFed " << dumpSelectedSiStripFed_
       << " DumpSelectedSiPixelFed " << dumpSelectedSiPixelFed_ << std::endl;
  
   if (iConfig.existsAs<bool>("dumpAllEcalFed"))
     dumpAllEcalFed_ = iConfig.getParameter<bool>("dumpAllEcalFed");
   else
     dumpAllEcalFed_ = false;
  
   if (iConfig.existsAs<bool>("dumpAllTrackerFed"))
     dumpAllTrackerFed_ = iConfig.getParameter<bool>("dumpAllTrackerFed");
   else
     dumpAllTrackerFed_ = false;
  
   if (iConfig.existsAs<bool>("dumpAllHCALFed"))
     dumpAllHCALFed_ = iConfig.getParameter<bool>("dumpAllHCALFed");
   else
     dumpAllHCALFed_ = false;
  
   LogDebug("SelectedElectronFEDListProducer")
       << " DumpAllEcalFed " << dumpAllEcalFed_ << " DumpAllTrackerFed " << dumpAllTrackerFed_ << " Dump all HCAL fed "
       << dumpAllHCALFed_ << std::endl;
  
   // initialize pre-shower fed id --> look up table
   for (int i = 0; i < 2; ++i)
     for (int j = 0; j < 2; ++j)
       for (int k = 0; k < 40; ++k)
         for (int m = 0; m < 40; m++)
           ES_fedId_[i][j][k][m] = -1;
  
   // read in look-up table
   int nLines, iz, ip, ix, iy, fed, kchip, pace, bundle, fiber, optorx;
   std::ifstream ES_file;
   ES_file.open(ESLookupTable_.fullPath().c_str());
   LogDebug("SelectedElectronFEDListProducer")
       << " Look Up table for ES " << ESLookupTable_.fullPath().c_str() << std::endl;
   if (ES_file.is_open()) {
     ES_file >> nLines;
     for (int i = 0; i < nLines; ++i) {
       ES_file >> iz >> ip >> ix >> iy >> fed >> kchip >> pace >> bundle >> fiber >> optorx;
       ES_fedId_[(3 - iz) / 2 - 1][ip - 1][ix - 1][iy - 1] = fed;
     }
   } else
     LogDebug("SelectedElectronFEDListProducer")
         << " Look up table file can not be found in " << ESLookupTable_.fullPath().c_str() << std::endl;
   ES_file.close();
  
   // produce the final collection
   produces<FEDRawDataCollection>(outputLabelModule_);  // produce exit collection
 }

References Exception, edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), mps_fire::i, HLT_2018_cff::InputTag, dqmiolumiharvest::j, dqmdumpme::k, LogDebug, visualization-live-secondInstance_cfg::m, submitDQMOfflineCAF::nLines, or, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ ~SelectedElectronFEDListProducer()

template<typename TEle , typename TCand >

SelectedElectronFEDListProducer< TEle, TCand >::~SelectedElectronFEDListProducer ( )

override

Definition at line 286 of file SelectedElectronFEDListProducer.cc.

                                                                                {
   if (!electronTags_.empty())
     electronTags_.clear();
   if (!recoEcalCandidateTags_.empty())
     recoEcalCandidateTags_.clear();
   if (!recoEcalCandidateToken_.empty())
     recoEcalCandidateToken_.clear();
   if (!electronToken_.empty())
     electronToken_.clear();
   if (!fedList_.empty())
     fedList_.clear();
   if (!pixelModuleVector_.empty())
     pixelModuleVector_.clear();
 }

Member Function Documentation

◆ beginJob()

template<typename TEle , typename TCand >

void SelectedElectronFEDListProducer< TEle, TCand >::beginJob ( void )

protectedvirtual

Definition at line 302 of file SelectedElectronFEDListProducer.cc.

                                                             {
   LogDebug("SelectedElectronFEDListProducer") << " Begin of the Job " << std::endl;
 }

References LogDebug.

◆ endJob()

template<typename TEle , typename TCand >

void SelectedElectronFEDListProducer< TEle, TCand >::endJob ( void )

protectedvirtual

Definition at line 688 of file SelectedElectronFEDListProducer.cc.

                                                           {
   LogDebug("SelectedElectronFEDListProducer") << " End of the Job " << std::endl;
 }

References LogDebug.

Referenced by o2olib.O2ORunMgr::executeJob().

◆ fillDescriptions()

template<typename TEle , typename TCand >

void SelectedElectronFEDListProducer< TEle, TCand >::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 718 of file SelectedElectronFEDListProducer.cc.

                                                                                                               {
   edm::ParameterSetDescription desc;
   desc.add<vector<edm::InputTag>>("electronTags", {edm::InputTag("hltEgammaGsfElectrons")});
   desc.add<vector<edm::InputTag>>("recoEcalCandidateTags", {edm::InputTag("hltL1EG25Ele27WP85GsfTrackIsoFilter")});
   desc.add<edm::FileInPath>("ESLookupTable", edm::FileInPath("EventFilter/ESDigiToRaw/data/ES_lookup_table.dat"));
   desc.add<edm::InputTag>("HBHERecHitTag", edm::InputTag("hltHbhereco"));
   desc.add<edm::InputTag>("beamSpotTag", edm::InputTag("hltOnlineBeamSpot"));
   desc.add<edm::InputTag>("rawDataTag", edm::InputTag("rawDataCollector"));
   desc.add<vector<int>>("addThisSelectedFEDs", {812, 813});
   desc.add<vector<int>>("isGsfElectronCollection", {true});
   desc.add<std::string>("outputLabelModule", "StreamElectronRawFed");
   desc.add<bool>("dumpSelectedSiPixelFed", true);
   desc.add<bool>("dumpSelectedSiStripFed", true);
   desc.add<bool>("dumpSelectedEcalFed", true);
   desc.add<bool>("dumpSelectedHCALFed", true);
   desc.add<double>("dPhiPixelRegion", 0.3);
   desc.add<double>("dEtaPixelRegion", 0.3);
   desc.add<double>("dRStripRegion", 0.3);
   desc.add<double>("dRHcalRegion", 0.3);
   desc.add<double>("maxZPixelRegion", 24);
   desc.add<bool>("dumpAllTrackerFed", false);
   desc.add<bool>("dumpAllEcalFed", false);
   desc.add<bool>("dumpAllHcalFed", false);
  
   descriptions.add(defaultModuleLabel<SelectedElectronFEDListProducer<TEle, TCand>>(), desc);
 }

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), defaultModuleLabel(), HLT_2018_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ pixelFedDump()

template<typename TEle , typename TCand >

void SelectedElectronFEDListProducer< TEle, TCand >::pixelFedDump	(	std::vector< PixelModule >::const_iterator &	itDn,
		std::vector< PixelModule >::const_iterator &	itUp,
		const PixelRegion &	region
	)

Definition at line 693 of file SelectedElectronFEDListProducer.cc.

                                                                                            {
   for (; itDn != itUp; ++itDn) {
     float zmodule = itDn->z - ((itDn->x - beamSpotPosition_.x()) * region.cosphi +
                                (itDn->y - beamSpotPosition_.y()) * region.sinphi) *
                                   region.atantheta;
     if (std::abs(zmodule) > region.maxZ)
       continue;
     int hitFED = itDn->Fed;
     if (hitFED < FEDNumbering::MINSiPixelFEDID || hitFED > FEDNumbering::MAXSiPixelFEDID)
       continue;
     LogDebug("SelectedElectronFEDListProducer")
         << " electron pixel hit " << itDn->DetId << " hitFED " << hitFED << std::endl;
     if (!fedList_.empty()) {
       if (std::find(fedList_.begin(), fedList_.end(), hitFED) == fedList_.end())
         fedList_.push_back(hitFED);
     } else
       fedList_.push_back(hitFED);
   }
  
   return;
 }

References funct::abs(), spr::find(), LogDebug, FEDNumbering::MAXSiPixelFEDID, and HLT_2018_cff::region.

◆ produce()

template<typename TEle , typename TCand >

void SelectedElectronFEDListProducer< TEle, TCand >::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprotected

Definition at line 307 of file SelectedElectronFEDListProducer.cc.

                                                                                                         {
   // get the hcal electronics map
   edm::ESHandle<HcalDbService> pSetup;
   iSetup.get<HcalDbRecord>().get(pSetup);
   HcalReadoutMap_ = pSetup->getHcalMapping();
  
   // get the ecal electronics map
   edm::ESHandle<EcalElectronicsMapping> ecalmapping;
   iSetup.get<EcalMappingRcd>().get(ecalmapping);
   EcalMapping_ = ecalmapping.product();
  
   // get the calo geometry
   edm::ESHandle<CaloGeometry> caloGeometry;
   iSetup.get<CaloGeometryRecord>().get(caloGeometry);
   GeometryCalo_ = caloGeometry.product();
  
   //ES geometry
   GeometryES_ = caloGeometry->getSubdetectorGeometry(DetId::Ecal, EcalPreshower);
  
   // pixel tracker cabling map
   edm::ESTransientHandle<SiPixelFedCablingMap> pixelCablingMap;
   iSetup.get<SiPixelFedCablingMapRcd>().get(pixelCablingMap);
   PixelCabling_.reset();
   PixelCabling_ = pixelCablingMap->cablingTree();
  
   edm::ESHandle<TrackerGeometry> trackerGeometry;
   iSetup.get<TrackerDigiGeometryRecord>().get(trackerGeometry);
  
   if (pixelModuleVector_.empty()) {
     // build the tracker pixel module map
     std::vector<const GeomDet*>::const_iterator itTracker = trackerGeometry->dets().begin();
     for (; itTracker != trackerGeometry->dets().end(); ++itTracker) {
       int subdet = (*itTracker)->geographicalId().subdetId();
       if (!(subdet == PixelSubdetector::PixelBarrel || subdet == PixelSubdetector::PixelEndcap))
         continue;
       PixelModule module;
       module.x = (*itTracker)->position().x();
       module.y = (*itTracker)->position().y();
       module.z = (*itTracker)->position().z();
       module.Phi = (*itTracker)->position().phi();
       module.Eta = (*itTracker)->position().eta();
       module.DetId = (*itTracker)->geographicalId().rawId();
       const std::vector<sipixelobjects::CablingPathToDetUnit> path2det = PixelCabling_->pathToDetUnit(module.DetId);
       module.Fed = path2det[0].fed;
  
       pixelModuleVector_.push_back(module);
     }
     std::sort(pixelModuleVector_.begin(), pixelModuleVector_.end());
   }
  
   edm::ESHandle<SiStripRegionCabling> SiStripCablingHandle;
   iSetup.get<SiStripRegionCablingRcd>().get(SiStripCablingHandle);
   StripRegionCabling_ = SiStripCablingHandle.product();
  
   SiStripRegionCabling::Cabling SiStripCabling;
   SiStripCabling = StripRegionCabling_->getRegionCabling();
   regionDimension_ = StripRegionCabling_->regionDimensions();
  
   // event by event analysis
   // Get event raw data
   edm::Handle<FEDRawDataCollection> rawdata;
   if (!(rawDataTag_ == edm::InputTag("")))
     iEvent.getByToken(rawDataToken_, rawdata);
  
   // take the beam spot position
   edm::Handle<reco::BeamSpot> beamSpot;
   if (!(beamSpotTag_ == edm::InputTag("")))
     iEvent.getByToken(beamSpotToken_, beamSpot);
   if (!beamSpot.failedToGet())
     beamSpotPosition_ = beamSpot->position();
   else
     beamSpotPosition_.SetXYZ(0, 0, 0);
  
   // take the calo tower collection
   edm::Handle<HBHERecHitCollection> hbheRecHitHandle;
   if (!(HBHERecHitTag_ == edm::InputTag("")))
     iEvent.getByToken(hbheRecHitToken_, hbheRecHitHandle);
   const HBHERecHitCollection* hcalRecHitCollection = nullptr;
   if (!hbheRecHitHandle.failedToGet())
     hcalRecHitCollection = hbheRecHitHandle.product();
  
   double radTodeg = 180. / Geom::pi();
  
   if (dumpAllEcalFed_) {
     for (uint32_t iEcalFed = FEDNumbering::MINECALFEDID; iEcalFed <= FEDNumbering::MAXECALFEDID; iEcalFed++)
       fedList_.push_back(iEcalFed);
     for (uint32_t iESFed = FEDNumbering::MINPreShowerFEDID; iESFed <= FEDNumbering::MAXPreShowerFEDID; iESFed++)
       fedList_.push_back(iESFed);
   }
  
   if (dumpAllTrackerFed_) {
     for (uint32_t iPixelFed = FEDNumbering::MINSiPixelFEDID; iPixelFed <= FEDNumbering::MAXSiPixelFEDID; iPixelFed++)
       fedList_.push_back(iPixelFed);
     for (uint32_t iStripFed = FEDNumbering::MINSiStripFEDID; iStripFed <= FEDNumbering::MAXSiStripFEDID; iStripFed++)
       fedList_.push_back(iStripFed);
   }
  
   if (dumpAllHCALFed_) {
     for (uint32_t iHcalFed = FEDNumbering::MINHCALFEDID; iHcalFed <= FEDNumbering::MAXHCALFEDID; iHcalFed++)
       fedList_.push_back(iHcalFed);
   }
  
   // loop on the input electron collection vector
   TEle electron;
   edm::Ref<TCandColl> recoEcalCand;
   edm::Handle<TEleColl> electrons;
   edm::Handle<trigger::TriggerFilterObjectWithRefs> triggerRecoEcalCandidateCollection;
   std::vector<edm::Ref<TCandColl>> recoEcalCandColl;
  
   // iterator to electron and ecal candidate collections
   typename std::vector<edm::EDGetTokenT<TEleColl>>::const_iterator itElectronColl = electronToken_.begin();
   std::vector<int>::const_iterator itElectronCollFlag = isGsfElectronCollection_.begin();
   std::vector<edm::EDGetTokenT<trigger::TriggerFilterObjectWithRefs>>::const_iterator itRecoEcalCandColl =
       recoEcalCandidateToken_.begin();
  
   // if you want to dump just FED related to the triggering electron/s
   if (!dumpAllTrackerFed_ || !dumpAllEcalFed_) {
     // loop on the same time on ecal candidate and elctron collection and boolean for Gsf ones
     for (; itRecoEcalCandColl != recoEcalCandidateToken_.end() and itElectronColl != electronToken_.end() and
            itElectronCollFlag != isGsfElectronCollection_.end();
          ++itElectronColl, ++itElectronCollFlag, ++itRecoEcalCandColl) {
       // get ecal candidate collection
       iEvent.getByToken(*itRecoEcalCandColl, triggerRecoEcalCandidateCollection);
       if (triggerRecoEcalCandidateCollection.failedToGet())
         continue;
  
       // get gsf electron collection
       iEvent.getByToken(*itElectronColl, electrons);
       if (electrons.failedToGet())
         continue;
  
       triggerRecoEcalCandidateCollection->getObjects(trigger::TriggerCluster, recoEcalCandColl);
       if (recoEcalCandColl.empty())
         triggerRecoEcalCandidateCollection->getObjects(trigger::TriggerPhoton, recoEcalCandColl);
       if (recoEcalCandColl.empty())
         triggerRecoEcalCandidateCollection->getObjects(trigger::TriggerElectron, recoEcalCandColl);
  
       typename std::vector<edm::Ref<TCandColl>>::const_iterator itRecoEcalCand =
           recoEcalCandColl.begin();  // loop on recoEcalCandidate objects
  
       // loop on the recoEcalCandidates
       for (; itRecoEcalCand != recoEcalCandColl.end(); ++itRecoEcalCand) {
         recoEcalCand = (*itRecoEcalCand);
         reco::SuperClusterRef scRefRecoEcalCand =
             recoEcalCand->superCluster();  // take the supercluster in order to match with electron objects
  
         typename TEleColl::const_iterator itEle = electrons->begin();
         for (; itEle != electrons->end(); ++itEle) {  // loop on all the electrons inside a collection
           // get electron supercluster and the associated hit -> detID
           electron = (*itEle);
           reco::SuperClusterRef scRef = electron.superCluster();
           if (scRefRecoEcalCand != scRef)
             continue;  // mathching
  
           const std::vector<std::pair<DetId, float>>& hits = scRef->hitsAndFractions();
           // start in dump the ecal FED associated to the electron
           std::vector<std::pair<DetId, float>>::const_iterator itSChits = hits.begin();
           if (!dumpAllEcalFed_) {
             for (; itSChits != hits.end(); ++itSChits) {
               if ((*itSChits).first.subdetId() == EcalBarrel) {  // barrel part
                 EBDetId idEBRaw((*itSChits).first);
                 GlobalPoint point = GeometryCalo_->getPosition(idEBRaw);
                 int hitFED = FEDNumbering::MINECALFEDID +
                              EcalMapping_->GetFED(double(point.eta()), double(point.phi()) * radTodeg);
                 if (hitFED < FEDNumbering::MINECALFEDID || hitFED > FEDNumbering::MAXECALFEDID)
                   continue;
  
                 LogDebug("SelectedElectronFEDListProducer")
                     << " electron hit detID Barrel " << (*itSChits).first.rawId() << " eta " << double(point.eta())
                     << " phi " << double(point.phi()) * radTodeg << " FED " << hitFED << std::endl;
  
                 if (dumpSelectedEcalFed_) {
                   if (!fedList_.empty()) {
                     if (std::find(fedList_.begin(), fedList_.end(), hitFED) == fedList_.end())
                       fedList_.push_back(hitFED);  // in order not to duplicate info
                   } else
                     fedList_.push_back(hitFED);
                 }
               } else if ((*itSChits).first.subdetId() == EcalEndcap) {  // endcap one
                 EEDetId idEERaw((*itSChits).first);
                 GlobalPoint point = GeometryCalo_->getPosition(idEERaw);
                 int hitFED = FEDNumbering::MINECALFEDID +
                              EcalMapping_->GetFED(double(point.eta()), double(point.phi()) * radTodeg);
                 if (hitFED < FEDNumbering::MINECALFEDID || hitFED > FEDNumbering::MAXECALFEDID)
                   continue;
  
                 LogDebug("SelectedElectronFEDListProducer")
                     << " electron hit detID Endcap " << (*itSChits).first.rawId() << " eta " << double(point.eta())
                     << " phi " << double(point.phi()) * radTodeg << " FED " << hitFED << std::endl;
                 if (dumpSelectedEcalFed_) {
                   if (!fedList_.empty()) {
                     if (std::find(fedList_.begin(), fedList_.end(), hitFED) == fedList_.end())
                       fedList_.push_back(hitFED);
                   } else
                     fedList_.push_back(hitFED);
  
                   // preshower hit for each ecal endcap hit
                   DetId tmpX =
                       (dynamic_cast<const EcalPreshowerGeometry*>(GeometryES_))->getClosestCellInPlane(point, 1);
                   ESDetId stripX = (tmpX == DetId(0)) ? ESDetId(0) : ESDetId(tmpX);
                   int hitFED =
                       ES_fedId_[(3 - stripX.zside()) / 2 - 1][stripX.plane() - 1][stripX.six() - 1][stripX.siy() - 1];
                   LogDebug("SelectedElectronFEDListProducer")
                       << " ES hit plane X (deiID) " << stripX.rawId() << " six " << stripX.six() << " siy "
                       << stripX.siy() << " plane " << stripX.plane() << " FED ID " << hitFED << std::endl;
                   if (hitFED < FEDNumbering::MINPreShowerFEDID || hitFED > FEDNumbering::MAXPreShowerFEDID)
                     continue;
                   if (hitFED < 0)
                     continue;
                   if (!fedList_.empty()) {
                     if (std::find(fedList_.begin(), fedList_.end(), hitFED) == fedList_.end())
                       fedList_.push_back(hitFED);
                   } else
                     fedList_.push_back(hitFED);
  
                   DetId tmpY =
                       (dynamic_cast<const EcalPreshowerGeometry*>(GeometryES_))->getClosestCellInPlane(point, 2);
                   ESDetId stripY = (tmpY == DetId(0)) ? ESDetId(0) : ESDetId(tmpY);
                   hitFED =
                       ES_fedId_[(3 - stripY.zside()) / 2 - 1][stripY.plane() - 1][stripY.six() - 1][stripY.siy() - 1];
                   if (hitFED < FEDNumbering::MINPreShowerFEDID || hitFED > FEDNumbering::MAXPreShowerFEDID)
                     continue;
                   LogDebug("SelectedElectronFEDListProducer")
                       << " ES hit plane Y (deiID) " << stripY.rawId() << " six " << stripY.six() << " siy "
                       << stripY.siy() << " plane " << stripY.plane() << " FED ID " << hitFED << std::endl;
                   if (hitFED < 0)
                     continue;
                   if (!fedList_.empty()) {
                     if (std::find(fedList_.begin(), fedList_.end(), hitFED) == fedList_.end())
                       fedList_.push_back(hitFED);
                   } else
                     fedList_.push_back(hitFED);
                 }
               }  // end endcap
             }    // end loop on SC hit
  
             // check HCAL behind each hit
             if (dumpSelectedHCALFed_) {
               HBHERecHitCollection::const_iterator itHcalRecHit = hcalRecHitCollection->begin();
               for (; itHcalRecHit != hcalRecHitCollection->end(); ++itHcalRecHit) {
                 HcalDetId recHitId(itHcalRecHit->id());
                 const HcalGeometry* cellGeometry =
                     static_cast<const HcalGeometry*>(GeometryCalo_->getSubdetectorGeometry(recHitId));
                 float dR = reco::deltaR(scRef->eta(),
                                         scRef->phi(),
                                         cellGeometry->getPosition(recHitId).eta(),
                                         cellGeometry->getPosition(recHitId).phi());
                 if (dR <= dRHcalRegion_) {
                   const HcalElectronicsId electronicId = HcalReadoutMap_->lookup(recHitId);
                   int hitFED = electronicId.dccid() + FEDNumbering::MINHCALFEDID;
                   LogDebug("SelectedElectronFEDListProducer")
                       << " matched hcal recHit : HcalDetId " << recHitId << " HcalElectronicsId " << electronicId
                       << " dcc id " << electronicId.dccid() << " spigot " << electronicId.spigot() << " fiber channel "
                       << electronicId.fiberChanId() << " fiber index " << electronicId.fiberIndex() << std::endl;
                   if (hitFED < FEDNumbering::MINHCALFEDID || hitFED > FEDNumbering::MAXHCALFEDID)
                     continue;  //first eighteen feds are for HBHE
                   if (hitFED < 0)
                     continue;
                   if (!fedList_.empty()) {
                     if (std::find(fedList_.begin(), fedList_.end(), hitFED) == fedList_.end())
                       fedList_.push_back(hitFED);
                   } else
                     fedList_.push_back(hitFED);
                 }
               }
             }  // End Hcal
           }    // End Ecal
  
           // get the electron track
           if (!dumpAllTrackerFed_) {
             //loop on the region
             if (dumpSelectedSiStripFed_) {
               double eta;
               double phi;
               if (*itElectronCollFlag) {
                 eta = electron.gsfTrack()->eta();
                 phi = electron.gsfTrack()->phi();
               } else {
                 eta = electron.track()->eta();
                 phi = electron.track()->phi();
               }
               for (uint32_t iCabling = 0; iCabling < SiStripCabling.size(); iCabling++) {
                 SiStripRegionCabling::Position pos = StripRegionCabling_->position(iCabling);
                 double dphi = fabs(pos.second - phi);
                 if (dphi > acos(-1))
                   dphi = 2 * acos(-1) - dphi;
                 double R = sqrt(pow(pos.first - eta, 2) + dphi * dphi);
                 if (R - sqrt(pow(regionDimension_.first / 2, 2) + pow(regionDimension_.second / 2, 2)) > dRStripRegion_)
                   continue;
                 //get vector of subdets within region
                 const SiStripRegionCabling::RegionCabling regSubdets = SiStripCabling[iCabling];
                 //cycle on subdets
                 for (uint32_t idet = 0; idet < SiStripRegionCabling::ALLSUBDETS; idet++) {  //cicle between 1 and 4
                   //get vector of layers whin subdet of region
                   const SiStripRegionCabling::WedgeCabling regSubdetLayers = regSubdets[idet];  // at most 10 layers
                   for (uint32_t ilayer = 0; ilayer < SiStripRegionCabling::ALLLAYERS; ilayer++) {
                     //get map of vectors of feds withing the layer of subdet of region
                     const SiStripRegionCabling::ElementCabling fedVectorMap =
                         regSubdetLayers[ilayer];  // vector of the fed
                     SiStripRegionCabling::ElementCabling::const_iterator itFedMap = fedVectorMap.begin();
                     for (; itFedMap != fedVectorMap.end(); itFedMap++) {
                       for (uint32_t op = 0; op < (itFedMap->second).size(); op++) {
                         int hitFED = (itFedMap->second)[op].fedId();
                         if (hitFED < FEDNumbering::MINSiStripFEDID || hitFED > FEDNumbering::MAXSiStripFEDID)
                           continue;
                         LogDebug("SelectedElectronFEDListProducer") << " SiStrip (FedID) " << hitFED << std::endl;
                         if (!fedList_.empty()) {
                           if (std::find(fedList_.begin(), fedList_.end(), hitFED) == fedList_.end())
                             fedList_.push_back(hitFED);
                         } else
                           fedList_.push_back(hitFED);
                       }
                     }
                   }
                 }
               }
             }  // end si strip
             if (dumpSelectedSiPixelFed_) {
               math::XYZVector momentum;
               if (*itElectronCollFlag)
                 momentum = electron.gsfTrack()->momentum();
               else
                 momentum = electron.track()->momentum();
               PixelRegion region(momentum, dPhiPixelRegion_, dEtaPixelRegion_, maxZPixelRegion_);
               PixelModule lowerBound(region.vector.phi() - region.dPhi, region.vector.eta() - region.dEta);
               PixelModule upperBound(region.vector.phi() + region.dPhi, region.vector.eta() + region.dEta);
  
               std::vector<PixelModule>::const_iterator itUp, itDn;
               if (lowerBound.Phi >= -M_PI && upperBound.Phi <= M_PI) {
                 itDn = std::lower_bound(pixelModuleVector_.begin(), pixelModuleVector_.end(), lowerBound);
                 itUp = std::upper_bound(pixelModuleVector_.begin(), pixelModuleVector_.end(), upperBound);
                 pixelFedDump(itDn, itUp, region);
               } else {
                 if (lowerBound.Phi < -M_PI)
                   lowerBound.Phi = lowerBound.Phi + 2 * M_PI;
                 PixelModule phi_p(M_PI, region.vector.eta() - region.dEta);
                 itDn = std::lower_bound(pixelModuleVector_.begin(), pixelModuleVector_.end(), lowerBound);
                 itUp = std::upper_bound(pixelModuleVector_.begin(), pixelModuleVector_.end(), phi_p);
                 pixelFedDump(itDn, itUp, region);
  
                 if (upperBound.Phi < -M_PI)
                   upperBound.Phi = upperBound.Phi - 2 * M_PI;
                 PixelModule phi_m(-M_PI, region.vector.eta() - region.dEta);
                 itDn = std::lower_bound(pixelModuleVector_.begin(), pixelModuleVector_.end(), phi_m);
                 itUp = std::upper_bound(pixelModuleVector_.begin(), pixelModuleVector_.end(), upperBound);
                 pixelFedDump(itDn, itUp, region);
               }
             }
           }  // end tracker analysis
         }    // end loop on the electron candidate
       }      // end loop on the electron collection collection
     }        // end loop on the recoEcal candidate
   }          // end loop on the recoEcal candidate collection
   // add a set of chosen FED
   for (unsigned int iFed = 0; iFed < addThisSelectedFEDs_.size(); iFed++) {
     if (addThisSelectedFEDs_.at(iFed) == -1)
       continue;
     fedList_.push_back(addThisSelectedFEDs_.at(iFed));
   }
  
   // make the final raw data collection
   auto streamFEDRawProduct = std::make_unique<FEDRawDataCollection>();
   std::sort(fedList_.begin(), fedList_.end());
   std::vector<uint32_t>::const_iterator itfedList = fedList_.begin();
   for (; itfedList != fedList_.end(); ++itfedList) {
     LogDebug("SelectedElectronFEDListProducer") << " fed point " << *itfedList << "  ";
     const FEDRawData& data = rawdata->FEDData(*itfedList);
     if (data.size() > 0) {
       FEDRawData& fedData = streamFEDRawProduct->FEDData(*itfedList);
       fedData.resize(data.size());
       memcpy(fedData.data(), data.data(), data.size());
     }
   }
  
   iEvent.put(std::move(streamFEDRawProduct), outputLabelModule_);
  
   if (!fedList_.empty())
     fedList_.clear();
 }