#include <EcalSelectiveReadoutProducer.h>

Inheritance diagram for EcalSelectiveReadoutProducer:

Public Member Functions
	EcalSelectiveReadoutProducer (const edm::ParameterSet &params)

virtual void	produce (edm::Event &event, const edm::EventSetup &eventSetup)

virtual	~EcalSelectiveReadoutProducer ()

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

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Static Public Member Functions
static void	printSrFlags (std::ostream &os, const EBSrFlagCollection &ebSrFlags, const EESrFlagCollection &eeSrFlags, int iEvent=-1, bool withHeader=true)

Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
void	checkWeights (const edm::Event &evt, const edm::ProductID &noZSDigiId) const

bool	getBinOfMax (const edm::Event &evt, const edm::ProductID &noZsDigiId, int &binOfMax) const

const EBDigiCollection *	getEBDigis (edm::Event &event) const

const EEDigiCollection *	getEEDigis (edm::Event &event) const

const EcalTrigPrimDigiCollection *	getTrigPrims (edm::Event &event) const

void	printTTFlags (const EcalTrigPrimDigiCollection &tp, std::ostream &os) const


void	checkGeometry (const edm::EventSetup &eventSetup)

void	checkTriggerMap (const edm::EventSetup &eventSetup)

void	checkElecMap (const edm::EventSetup &eventSetup)

Static Private Member Functions
static void	checkValidity (const EcalSRSettings &settings)

Private Attributes
std::string	digiProducer_

int	dumpFlags_

std::string	ebdigiCollection_

std::string	ebSrFlagCollection_

std::string	ebSRPdigiCollection_

std::string	eedigiCollection_

std::string	eeSrFlagCollection_

std::string	eeSRPdigiCollection_

edm::ParameterSet	params_

bool	produceDigis_

const EcalSRSettings *	settings_

std::auto_ptr< EcalSRSettings >	settingsFromFile_

std::auto_ptr < EcalSelectiveReadoutSuppressor >	suppressor_

const EcalElectronicsMapping *	theElecMap

const CaloGeometry *	theGeometry

const EcalTrigTowerConstituentsMap *	theTriggerTowerMap

bool	trigPrimBypass_

int	trigPrimBypassMode_

std::string	trigPrimCollection_

std::string	trigPrimProducer_

bool	useCondDb_

bool	useFullReadout_

bool	writeSrFlags_

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

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 17 of file EcalSelectiveReadoutProducer.h.

Constructor & Destructor Documentation

EcalSelectiveReadoutProducer::EcalSelectiveReadoutProducer ( const edm::ParameterSet & params )

explicit

Constructor

Parameters

params seletive readout parameters

Definition at line 21 of file EcalSelectiveReadoutProducer.cc.

References digiProducer_, dumpFlags_, ebdigiCollection_, ebSrFlagCollection_, ebSRPdigiCollection_, eedigiCollection_, eeSrFlagCollection_, eeSRPdigiCollection_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), EcalSRCondTools::importParameterSet(), produceDigis_, settings_, settingsFromFile_, AlCaHLTBitMon_QueryRunRegistry::string, theElecMap, theGeometry, theTriggerTowerMap, trigPrimBypass_, trigPrimBypassMode_, trigPrimCollection_, trigPrimProducer_, useCondDb_, useFullReadout_, and writeSrFlags_.

   : params_(params)
 {
   //settings:
   //  settings which are only in python config files:
   digiProducer_ = params.getParameter<string>("digiProducer");
   ebdigiCollection_ = params.getParameter<std::string>("EBdigiCollection");
   eedigiCollection_ = params.getParameter<std::string>("EEdigiCollection");
   ebSRPdigiCollection_ = params.getParameter<std::string>("EBSRPdigiCollection");
   eeSRPdigiCollection_ = params.getParameter<std::string>("EESRPdigiCollection");
   ebSrFlagCollection_ = params.getParameter<std::string>("EBSrFlagCollection");
   eeSrFlagCollection_ = params.getParameter<std::string>("EESrFlagCollection");
   trigPrimProducer_ = params.getParameter<string>("trigPrimProducer");
   trigPrimCollection_ = params.getParameter<string>("trigPrimCollection");
   trigPrimBypass_ = params.getParameter<bool>("trigPrimBypass");
   trigPrimBypassMode_ = params.getParameter<int>("trigPrimBypassMode");
   dumpFlags_ = params.getUntrackedParameter<int>("dumpFlags", 0);
   writeSrFlags_ = params.getUntrackedParameter<bool>("writeSrFlags", false);
   produceDigis_ = params.getUntrackedParameter<bool>("produceDigis", true);
   //   settings which can come from either condition database or python configuration file:
   useCondDb_ = false;
   try{
     if(params.getParameter<bool>("configFromCondDB")){
       useCondDb_ = true;
     }
   } catch(cms::Exception){
     /* pameter not found */
     edm::LogWarning("EcalSelectiveReadout") << "Parameter configFromCondDB of EcalSelectiveReadout module not found. "
       "Selective readout configuration will be read from python file.";
   }
   if(!useCondDb_){
     settingsFromFile_ = auto_ptr<EcalSRSettings>(new EcalSRSettings());
     EcalSRCondTools::importParameterSet(*settingsFromFile_, params);
     settings_ = settingsFromFile_.get();
   }
 
   //declares the products made by this producer:
   if(produceDigis_){
     produces<EBDigiCollection>(ebSRPdigiCollection_);
     produces<EEDigiCollection>(eeSRPdigiCollection_);
   }
 
   if (writeSrFlags_) {
     produces<EBSrFlagCollection>(ebSrFlagCollection_);
     produces<EESrFlagCollection>(eeSrFlagCollection_);
   }
 
   useFullReadout_ = false;
   useFullReadout_ = params.getParameter<bool>("UseFullReadout");
 
   theGeometry = 0;
   theTriggerTowerMap = 0;
   theElecMap = 0;
 }

EcalSelectiveReadoutProducer::~EcalSelectiveReadoutProducer ( )

virtual

Destructor

Definition at line 78 of file EcalSelectiveReadoutProducer.cc.

79 { }

Member Function Documentation

void EcalSelectiveReadoutProducer::checkElecMap ( const edm::EventSetup & eventSetup )

private

Definition at line 252 of file EcalSelectiveReadoutProducer.cc.

References edm::EventSetup::get(), suppressor_, and theElecMap.

Referenced by produce().

 {
 
    edm::ESHandle<EcalElectronicsMapping> eElecmap;
    eventSetup.get<EcalMappingRcd>().get(eElecmap);
 
    const EcalElectronicsMapping * pMap = &*eElecmap;
 
   // see if we need to update
   if(pMap!= theElecMap) {
     theElecMap = pMap;
     suppressor_->setElecMap(theElecMap);
   }
 }

void EcalSelectiveReadoutProducer::checkGeometry ( const edm::EventSetup & eventSetup )

private

call these once an event, to make sure everything is up-to-date

Definition at line 221 of file EcalSelectiveReadoutProducer.cc.

References edm::EventSetup::get(), suppressor_, and theGeometry.

Referenced by produce().

 {
   edm::ESHandle<CaloGeometry> hGeometry;
   eventSetup.get<CaloGeometryRecord>().get(hGeometry);
 
   const CaloGeometry * pGeometry = &*hGeometry;
 
   // see if we need to update
   if(pGeometry != theGeometry) {
     theGeometry = pGeometry;
     suppressor_->setGeometry(theGeometry);
   }
 }

void EcalSelectiveReadoutProducer::checkTriggerMap ( const edm::EventSetup & eventSetup )

private

Definition at line 236 of file EcalSelectiveReadoutProducer.cc.

References edm::EventSetup::get(), suppressor_, and theTriggerTowerMap.

Referenced by produce().

 {
 
    edm::ESHandle<EcalTrigTowerConstituentsMap> eTTmap;
    eventSetup.get<IdealGeometryRecord>().get(eTTmap);
 
    const EcalTrigTowerConstituentsMap * pMap = &*eTTmap;
 
   // see if we need to update
   if(pMap!= theTriggerTowerMap) {
     theTriggerTowerMap = pMap;
     suppressor_->setTriggerMap(theTriggerTowerMap);
   }
 }

void EcalSelectiveReadoutProducer::checkValidity ( const EcalSRSettings & settings )

staticprivate

Checks validity of selective setting object is valid to be used for MC, especially checks the number of elements in the vectors

Parameters

forEmulator if true check the restriction that applies for EcalSelectiveReadoutProducer

Exceptions

cms::Exception if the setting is not valid.

Definition at line 505 of file EcalSelectiveReadoutProducer.cc.

References EcalSRSettings::dccNormalizedWeights_, EcalSRSettings::ecalDccZs1stSample_, and edm::hlt::Exception.

Referenced by produce().

                                                                               {
   if(settings.dccNormalizedWeights_.size() != 1){
     throw cms::Exception("Configuration") << "Selective readout emulator, EcalSelectiveReadout, supports only single set of ZS weights. "
       "while the configuration contains " << settings.dccNormalizedWeights_.size() << " set(s)\n";
   }
   
 //   if(settings.dccNormalizedWeights_.size() != 1
 //      && settings.dccNormalizedWeights_.size() != 2
 //      && settings.dccNormalizedWeights_.size() != 54
 //      && settings.dccNormalizedWeights_.size() != 75848){
 //     throw cms::Exception("Configuration") << "Invalid number of DCC weight set (" << settings.dccNormalizedWeights_.size()
 //                    << ") in condition object EcalSRSetting::dccNormalizedWeights_. "
 //                    << "Valid counts are: 1 (single set), 2 (EB and EE), 54 (one per DCC) and 75848 "
 //       "(one per crystal)\n";
 //   }
   
   if(settings.dccNormalizedWeights_.size() != settings.ecalDccZs1stSample_.size()){
     throw cms::Exception("Configuration") << "Inconsistency between number of weigth sets ("
                       << settings.dccNormalizedWeights_.size() << ") and "
                       << "number of ecalDccZs1Sample values ("
                       << settings.ecalDccZs1stSample_.size() << ").";
   }  
 }

void EcalSelectiveReadoutProducer::checkWeights	(	const edm::Event &	evt,
		const edm::ProductID &	noZSDigiId
	)		const

private

Sanity check on the DCC FIR filter weights. Log warning or error message if an unexpected weight set is found. In principle it is checked that the maximum weight is applied to the expected maximum sample.

Definition at line 304 of file EcalSelectiveReadoutProducer.cc.

References EcalSRSettings::dccNormalizedWeights_, EcalSRSettings::ecalDccZs1stSample_, getBinOfMax(), EcalSelectiveReadoutSuppressor::getFIRTapCount(), i, settings_, and create_public_pileup_plots::weights.

Referenced by getEBDigis(), and getEEDigis().

                                                              {
   const vector<float> & weights = settings_->dccNormalizedWeights_[0]; //params_.getParameter<vector<double> >("dccNormalizedWeights");
   int nFIRTaps = EcalSelectiveReadoutSuppressor::getFIRTapCount();
   static std::atomic<bool> warnWeightCnt{true};
   bool expected = true;
   if((int)weights.size() > nFIRTaps && warnWeightCnt.compare_exchange_strong(expected,false,std::memory_order_acq_rel)){
       edm::LogWarning("Configuration") << "The list of DCC zero suppression FIR "
     "weights given in parameter dccNormalizedWeights is longer "
     "than the expected depth of the FIR filter :(" << nFIRTaps << "). "
     "The last weights will be discarded.";
   }
 
   if(weights.size()>0){
     int iMaxWeight = 0;
     double maxWeight = weights[iMaxWeight];
     //looks for index of maximum weight
     for(unsigned i=0; i<weights.size(); ++i){
       if(weights[i]>maxWeight){
     iMaxWeight = i;
     maxWeight = weights[iMaxWeight];
       }
     }
 
     //position of time sample whose maximum weight is applied:
     int maxWeightBin = settings_->ecalDccZs1stSample_[0] //params_.getParameter<int>("ecalDccZs1stSample")
       + iMaxWeight;
     
     //gets the bin of maximum (in case of raw data it will not exist)
     int binOfMax = 0;
     bool rc = getBinOfMax(evt, noZsDigiId, binOfMax);
 
     if(rc && maxWeightBin!=binOfMax){
       edm::LogWarning("Configuration")
     << "The maximum weight of DCC zero suppression FIR filter is not "
     "applied to the expected maximum sample(" << binOfMax
     << (binOfMax==1?"st":(binOfMax==2?"nd":(binOfMax==3?"rd":"th")))
     << " time sample). This may indicate faulty 'dccNormalizedWeights' "
     "or 'ecalDccZs1sSample' parameters.";
     }
   }
 }

bool EcalSelectiveReadoutProducer::getBinOfMax	(	const edm::Event &	evt,
		const edm::ProductID &	noZsDigiId,
		int &	binOfMax
	)		const

private

Gets the value of the digitizer binOfMaximum parameter.

Parameters

noZsDigiId	product ID of the non-suppressed digis
binOfMax	[out] set the parameter value if found

Returns: true on success, false otherwise

Definition at line 348 of file EcalSelectiveReadoutProducer.cc.

References spr::find(), edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNames(), edm::Event::getProvenance(), AlCaHLTBitMon_ParallelJobs::p, edm::parameterSet(), and query::result.

Referenced by checkWeights().

                                           {
   bool rc;
   const edm::Provenance p=evt.getProvenance(noZsDigiId);
   const edm::ParameterSet& result = parameterSet(p);
   vector<string> ebDigiParamList = result.getParameterNames();
   string bofm("binOfMaximum");
   if(find(ebDigiParamList.begin(), ebDigiParamList.end(), bofm)
      != ebDigiParamList.end()){//bofm found
     binOfMax=result.getParameter<int>("binOfMaximum");
     rc = true;
   } else{
     rc = false;
   }
   return rc;
 }

const EBDigiCollection * EcalSelectiveReadoutProducer::getEBDigis ( edm::Event & event ) const

private

Definition at line 181 of file EcalSelectiveReadoutProducer.cc.

References checkWeights(), digiProducer_, ebdigiCollection_, edm::HandleBase::id(), edm::Handle< T >::product(), and query::result.

Referenced by produce().

 {
   edm::Handle<EBDigiCollection> hEBDigis;
   event.getByLabel(digiProducer_, ebdigiCollection_, hEBDigis);
   //product() method is called before id() in order to get an exception
   //if the handle is not available (check not done by id() method).
   const EBDigiCollection* result = hEBDigis.product();
   static bool firstCall= true;
   if(firstCall){
     checkWeights(event, hEBDigis.id());
     firstCall = false;
   }
   return result;
 }

const EEDigiCollection * EcalSelectiveReadoutProducer::getEEDigis ( edm::Event & event ) const

private

Definition at line 197 of file EcalSelectiveReadoutProducer.cc.

References checkWeights(), digiProducer_, eedigiCollection_, edm::HandleBase::id(), edm::Handle< T >::product(), and query::result.

Referenced by produce().

 {
   edm::Handle<EEDigiCollection> hEEDigis;
   event.getByLabel(digiProducer_, eedigiCollection_, hEEDigis);
   //product() method is called before id() in order to get an exception
   //if the handle is not available (check not done by id() method).
   const EEDigiCollection* result = hEEDigis.product();
   static bool firstCall = true;
   if(firstCall){
     checkWeights(event, hEEDigis.id());
     firstCall = false;
   }
   return result;
 }

const EcalTrigPrimDigiCollection * EcalSelectiveReadoutProducer::getTrigPrims ( edm::Event & event ) const

private

Definition at line 213 of file EcalSelectiveReadoutProducer.cc.

References edm::Handle< T >::product(), trigPrimCollection_, and trigPrimProducer_.

Referenced by produce().

 {
   edm::Handle<EcalTrigPrimDigiCollection> hTPDigis;
   event.getByLabel(trigPrimProducer_, trigPrimCollection_, hTPDigis);
   return hTPDigis.product();
 }

void EcalSelectiveReadoutProducer::printSrFlags	(	std::ostream &	os,
		const EBSrFlagCollection &	ebSrFlags,
		const EESrFlagCollection &	eeSrFlags,
		int	iEvent = `-1`,
		bool	withHeader = `true`
	)

static

Help function to print SR flags.

Parameters

ebSrFlags	the action flags of EB
eeSrFlag	the action flags of EE
iEvent	event number. Ignored if <0.
withHeader,if	true an output description is written out as header.

Definition at line 367 of file EcalSelectiveReadoutProducer.cc.

References edm::SortedCollection< T, SORT >::begin(), edm::SortedCollection< T, SORT >::end(), i, EBSrFlag::id(), EESrFlag::id(), EcalTrigTowerDetId::ieta(), EcalTrigTowerDetId::iphi(), EcalScDetId::ix(), EcalScDetId::iy(), nEndcaps, srpFlagMarker, lumiQTWidget::t, cond::rpcobgas::time, EcalSrFlag::value(), and EcalScDetId::zside().

Referenced by produce().

                                        {
   const char srpFlagMarker[] = {'.', 'z', 'Z', 'F', '4','5','6','7'};
   if(withHeader){
     time_t t;
     time(&t);
     const char* date = ctime(&t);
     os << "#SRP flag map\n#\n"
       "# Generatied on: " << date << "\n#\n"
       "# +-->Phi/Y " << srpFlagMarker[0] << ": suppressed\n"
       "# |         " << srpFlagMarker[1] << ": ZS 1\n"
       "# |         " << srpFlagMarker[2] << ": ZS 2\n"
       "# V Eta/X   " << srpFlagMarker[3] << ": full readout\n"
       "#\n";
   }
 
   //EE-,EB,EE+ map wil be written onto file in following format:
   //
   //      72
   // <-------------->
   //  20
   // <--->
   //  EEE                A             +-----> Y
   // EEEEE               |             |
   // EE EE               | 20   EE-    |
   // EEEEE               |             |
   //  EEE                V             V X
   // BBBBBBBBBBBBBBBBB   A
   // BBBBBBBBBBBBBBBBB   |             +-----> Phi
   // BBBBBBBBBBBBBBBBB   |             |
   // BBBBBBBBBBBBBBBBB   | 34  EB      |
   // BBBBBBBBBBBBBBBBB   |             |
   // BBBBBBBBBBBBBBBBB   |             V Eta
   // BBBBBBBBBBBBBBBBB   |
   // BBBBBBBBBBBBBBBBB   |
   // BBBBBBBBBBBBBBBBB   V
   //  EEE                A             +-----> Y
   // EEEEE               |             |
   // EE EE               | 20 EE+      |
   // EEEEE               |             |
   //  EEE                V             V X
   //
   //
   //
   //
   //event header:
   if(iEvent>=0){
     os << "# Event " << iEvent << "\n";
   }
 
   //retrieve flags:
   const int nEndcaps = 2;
   const int nScX = 20;
   const int nScY = 20;
   int eeSrf[nEndcaps][nScX][nScY];
   for(size_t i=0; i < sizeof(eeSrf)/sizeof(int); ((int*)eeSrf)[i++] = -1){};
   for(EESrFlagCollection::const_iterator it = eeSrFlags.begin();
       it != eeSrFlags.end(); ++it){
     const EESrFlag& flag = *it;
     int iZ0 = flag.id().zside()>0?1:0;
     int iX0 = flag.id().ix()-1;
     int iY0 = flag.id().iy()-1;
     assert(iZ0>=0 && iZ0<nEndcaps);
     assert(iX0>=0 && iX0<nScX);
     assert(iY0>=0 && iY0<nScY);
     eeSrf[iZ0][iX0][iY0] = flag.value();
   }
   const int nEbTtEta = 34;
   const int nEeTtEta = 11;
   const int nTtEta = nEeTtEta*2+nEbTtEta;
   const int nTtPhi = 72;
   int ebSrf[nEbTtEta][nTtPhi];
   for(size_t i=0; i<sizeof(ebSrf)/sizeof(int); ((int*)ebSrf)[i++] = -1){};
   for(EBSrFlagCollection::const_iterator it = ebSrFlags.begin();
       it != ebSrFlags.end(); ++it){
 
     const EBSrFlag& flag = *it;
     int iEta = flag.id().ieta();
     int iEta0 = iEta + nTtEta/2 - (iEta>=0?1:0); //0->55 from eta=-3 to eta=3
     int iEbEta0 = iEta0 - nEeTtEta;//0->33 from eta=-1.48 to eta=1.48
     int iPhi0 = flag.id().iphi() - 1;
     assert(iEbEta0>=0 && iEbEta0<nEbTtEta);
     assert(iPhi0>=0 && iPhi0<nTtPhi);
 
 //     cout << __FILE__ << ":" << __LINE__ << ": "
 //   <<  iEta << "\t" << flag.id().iphi() << " -> "
 //   << iEbEta0 << "\t" << iPhi0
 //   << "... Flag: " << flag.value() << "\n";
 
 
     ebSrf[iEbEta0][iPhi0] = flag.value();
   }
 
 
   //print flags:
 
   //EE-
   for(int iX0=0; iX0<nScX; ++iX0){
     for(int iY0=0; iY0<nScY; ++iY0){
       int srFlag = eeSrf[0][iX0][iY0];
       assert(srFlag>=-1
          && srFlag<(int)(sizeof(srpFlagMarker)/sizeof(srpFlagMarker[0])));
       os << (srFlag==-1?' ':srpFlagMarker[srFlag]);
     }
     os << "\n"; //one Y supercystal column per line
   } //next supercrystal X-index
 
   //EB
   for(int iEta0 = 0;
       iEta0 < nEbTtEta;
       ++iEta0){
     for(int iPhi0 = 0; iPhi0 < nTtPhi; ++iPhi0){
       int srFlag = ebSrf[iEta0][iPhi0];
       assert(srFlag>=-1
          && srFlag<(int)(sizeof(srpFlagMarker)/sizeof(srpFlagMarker[0])));
       os << (srFlag==-1?'?':srpFlagMarker[srFlag]);
     }
     os << "\n"; //one phi per line
   }
 
   //EE+
   for(int iX0=0; iX0<nScX; ++iX0){
     for(int iY0=0; iY0<nScY; ++iY0){
       int srFlag = eeSrf[1][iX0][iY0];
       assert(srFlag>=-1
          && srFlag<(int)(sizeof(srpFlagMarker)/sizeof(srpFlagMarker[0])));
       os << (srFlag==-1?' ':srpFlagMarker[srFlag]);
     }
     os << "\n"; //one Y supercystal column per line
   } //next supercrystal X-index
 
   //event trailer:
   os << "\n";
 }

void EcalSelectiveReadoutProducer::printTTFlags	(	const EcalTrigPrimDigiCollection &	tp,
		std::ostream &	os
	)		const

private

Definition at line 268 of file EcalSelectiveReadoutProducer.cc.

References edm::SortedCollection< T, SORT >::begin(), edm::SortedCollection< T, SORT >::end(), EcalTriggerPrimitiveDigi::id(), EcalTrigTowerDetId::ieta(), EcalTrigTowerDetId::iphi(), EcalSelectiveReadout::nTriggerTowersInEta, EcalSelectiveReadout::nTriggerTowersInPhi, EcalTriggerPrimitiveDigi::size(), tccFlagMarker, and EcalTriggerPrimitiveDigi::ttFlag().

                                                                                                       {
   const char tccFlagMarker[] = { 'x', '.', 'S', '?', 'C', 'E', 'E', 'E', 'E'};
   const int nEta = EcalSelectiveReadout::nTriggerTowersInEta;
   const int nPhi = EcalSelectiveReadout::nTriggerTowersInPhi;
 
   //static bool firstCall=true;
   //  if(firstCall){
   //  firstCall=false;
   os << "# TCC flag map\n#\n"
     "# +-->Phi            " << tccFlagMarker[0+1] << ": 000 (low interest)\n"
     "# |                  " << tccFlagMarker[1+1] << ": 001 (mid interest)\n"
     "# |                  " << tccFlagMarker[2+1] << ": 010 (not valid)\n"
     "# V Eta              " << tccFlagMarker[3+1] << ": 011 (high interest)\n"
     "#                    " << tccFlagMarker[4+1] << ": 1xx forced readout (Hw error)\n"
     "#\n";
   //}
 
   vector<vector<int> > ttf(nEta, vector<int>(nPhi, -1));
   for(EcalTrigPrimDigiCollection::const_iterator it = tp.begin();
       it != tp.end(); ++it){
     const EcalTriggerPrimitiveDigi& trigPrim = *it;
     if(trigPrim.size()>0){
       int iEta = trigPrim.id().ieta();
       int iEta0 = iEta<0?iEta+nEta/2:iEta+nEta/2-1;
       int iPhi0 = trigPrim.id().iphi() - 1;
       ttf[iEta0][iPhi0] = trigPrim.ttFlag();
     }
   }
   for(int iEta=0; iEta<nEta; ++iEta){
     for(int iPhi=0; iPhi<nPhi; ++iPhi){
       os << tccFlagMarker[ttf[iEta][iPhi]+1];
     }
     os << "\n";
   }
 }

void EcalSelectiveReadoutProducer::produce	(	edm::Event &	event,
		const edm::EventSetup &	eventSetup
	)

virtual

Produces the EDM products

Parameters

CMS	event
eventSetup	event conditions

Implements edm::EDProducer.

Definition at line 83 of file EcalSelectiveReadoutProducer.cc.

References checkElecMap(), checkGeometry(), checkTriggerMap(), checkValidity(), dumpFlags_, ebSrFlagCollection_, ebSRPdigiCollection_, eeSrFlagCollection_, eeSRPdigiCollection_, edm::EventSetup::get(), getEBDigis(), getEEDigis(), getTrigPrims(), iEvent, params_, printSrFlags(), produceDigis_, edm::ESHandle< class >::product(), settings_, suppressor_, trigPrimBypass_, trigPrimBypassMode_, estimatePileup_makeJSON::trunc, useCondDb_, useFullReadout_, and writeSrFlags_.

 {
   if(useCondDb_){
     //getting selective readout configuration:
     edm::ESHandle<EcalSRSettings> hSr;
 
     if(useFullReadout_){
       eventSetup.get<EcalSRSettingsRcd>().get("fullReadout",hSr);
     }
     else{
       eventSetup.get<EcalSRSettingsRcd>().get(hSr);
     }
     settings_ = hSr.product();
   }
   
   //gets the trigger primitives:
   EcalTrigPrimDigiCollection emptyTPColl;
   const EcalTrigPrimDigiCollection* trigPrims =
     (trigPrimBypass_ && trigPrimBypassMode_==0)?&emptyTPColl:getTrigPrims(event);
 
 
   //gets the digis from the events:
   EBDigiCollection dummyEbDigiColl;
   EEDigiCollection dummyEeDigiColl;
 
   const EBDigiCollection* ebDigis = produceDigis_?getEBDigis(event)
     :&dummyEbDigiColl;
   const EEDigiCollection* eeDigis = produceDigis_?getEEDigis(event)
     :&dummyEeDigiColl;
 
   //runs the selective readout algorithm:
   auto_ptr<EBDigiCollection> selectedEBDigis;
   auto_ptr<EEDigiCollection> selectedEEDigis;
   auto_ptr<EBSrFlagCollection> ebSrFlags;
   auto_ptr<EESrFlagCollection> eeSrFlags;
 
   if(produceDigis_){
     selectedEBDigis = auto_ptr<EBDigiCollection>(new EBDigiCollection);
     selectedEEDigis = auto_ptr<EEDigiCollection>(new EEDigiCollection);
   }
 
   if(writeSrFlags_){
     ebSrFlags = auto_ptr<EBSrFlagCollection>(new EBSrFlagCollection);
     eeSrFlags = auto_ptr<EESrFlagCollection>(new EESrFlagCollection);
   }
 
   if(suppressor_.get() == 0){
     //Check the validity of EcalSRSettings
     checkValidity(*settings_);
     
     //instantiates the selective readout algorithm:
     suppressor_ = auto_ptr<EcalSelectiveReadoutSuppressor>(new EcalSelectiveReadoutSuppressor(params_, settings_));
 
     // check that everything is up-to-date
     checkGeometry(eventSetup);
     checkTriggerMap(eventSetup);
     checkElecMap(eventSetup);
   }
   
   suppressor_->run(eventSetup, *trigPrims, *ebDigis, *eeDigis,
            selectedEBDigis.get(), selectedEEDigis.get(),
            ebSrFlags.get(), eeSrFlags.get());
 
   static int iEvent = 1;
   if(dumpFlags_>=iEvent){
     ofstream ttfFile("TTF.txt", (iEvent==1?ios::trunc:ios::app));
     suppressor_->printTTFlags(ttfFile, iEvent,
                   iEvent==1?true:false);
 
     ofstream srfFile("SRF.txt", (iEvent==1?ios::trunc:ios::app));
     if(iEvent==1){
       suppressor_->getEcalSelectiveReadout()->printHeader(srfFile);
     }
     srfFile << "# Event " << iEvent << "\n";
     suppressor_->getEcalSelectiveReadout()->print(srfFile);
     srfFile << "\n";
 
     ofstream afFile("AF.txt", (iEvent==1?ios::trunc:ios::app));
     printSrFlags(afFile, *ebSrFlags, *eeSrFlags, iEvent,
          iEvent==1?true:false);
   }
 
   ++iEvent; //event counter
 
   if(produceDigis_){
     //puts the selected digis into the event:
     event.put(selectedEBDigis, ebSRPdigiCollection_);
     event.put(selectedEEDigis, eeSRPdigiCollection_);
   }
 
   //puts the SR flags into the event:
   if(writeSrFlags_) {
     event.put(ebSrFlags, ebSrFlagCollection_);
     event.put(eeSrFlags, eeSrFlagCollection_);
   }
 }