Inheritance diagram for EcalDigisFromPortableProducer:

Public Member Functions
	EcalDigisFromPortableProducer (edm::ParameterSet const &ps)

	~EcalDigisFromPortableProducer () override=default

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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

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

Private Types
using	InputProduct = EcalDigiHostCollection

Private Member Functions
template<typename ProductType , typename... ARGS>
edm::EDPutTokenT< ProductType >	dummyProduces (ARGS &&... args)

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

Private Attributes
edm::EDGetTokenT< InputProduct >	digisInEBToken_

edm::EDGetTokenT< InputProduct >	digisInEEToken_

edm::EDPutTokenT< EBDigiCollection >	digisOutEBToken_

edm::EDPutTokenT< EEDigiCollection >	digisOutEEToken_

edm::EDPutTokenT< EBDetIdCollection >	ebIntegrityChIdErrorsToken_

edm::EDPutTokenT< EBDetIdCollection >	ebIntegrityGainErrorsToken_

edm::EDPutTokenT< EBDetIdCollection >	ebIntegrityGainSwitchErrorsToken_

edm::EDPutTokenT< EBSrFlagCollection >	ebSrFlagToken_

edm::EDPutTokenT< EcalElectronicsIdCollection >	ecalIntegrityMemBlockSizeErrorsToken_

edm::EDPutTokenT< EcalElectronicsIdCollection >	ecalIntegrityMemChIdErrorsToken_

edm::EDPutTokenT< EcalElectronicsIdCollection >	ecalIntegrityMemGainErrorsToken_

edm::EDPutTokenT< EcalElectronicsIdCollection >	ecalIntegrityMemTtIdErrorsToken_

edm::EDPutTokenT< EcalPSInputDigiCollection >	ecalPseudoStripInputsToken_

edm::EDPutTokenT< EcalRawDataCollection >	ecalRawDataToken_

edm::EDPutTokenT< EcalTrigPrimDigiCollection >	ecalTriggerPrimitivesToken_

edm::EDPutTokenT< EEDetIdCollection >	eeIntegrityChIdErrorsToken_

edm::EDPutTokenT< EEDetIdCollection >	eeIntegrityGainErrorsToken_

edm::EDPutTokenT< EEDetIdCollection >	eeIntegrityGainSwitchErrorsToken_

edm::EDPutTokenT< EESrFlagCollection >	eeSrFlagToken_

edm::EDPutTokenT< EcalElectronicsIdCollection >	integrityBlockSizeErrorsToken_

edm::EDPutTokenT< EcalElectronicsIdCollection >	integrityTTIdErrorsToken_

edm::EDPutTokenT< EcalElectronicsIdCollection >	integrityZSXtalIdErrorsToken_

edm::EDPutTokenT< EcalPnDiodeDigiCollection >	pnDiodeDigisToken_

bool	produceDummyIntegrityCollections_

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

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 15 of file EcalDigisFromPortableProducer.cc.

Member Typedef Documentation

◆ InputProduct

using EcalDigisFromPortableProducer::InputProduct = EcalDigiHostCollection

private

Definition at line 32 of file EcalDigisFromPortableProducer.cc.

Constructor & Destructor Documentation

◆ EcalDigisFromPortableProducer()

EcalDigisFromPortableProducer::EcalDigisFromPortableProducer ( edm::ParameterSet const & ps )

explicit

Definition at line 90 of file EcalDigisFromPortableProducer.cc.

References edm::ParameterSet::getParameter().

     :  // input digi collections on host in SoA format
       digisInEBToken_{consumes(ps.getParameter<edm::InputTag>("digisInLabelEB"))},
       digisInEEToken_{consumes(ps.getParameter<edm::InputTag>("digisInLabelEE"))},
 
       // output digi collections in legacy format
       digisOutEBToken_{produces<EBDigiCollection>(ps.getParameter<std::string>("digisOutLabelEB"))},
       digisOutEEToken_{produces<EEDigiCollection>(ps.getParameter<std::string>("digisOutLabelEE"))},
 
       // whether to produce dummy integrity collections
       produceDummyIntegrityCollections_{ps.getParameter<bool>("produceDummyIntegrityCollections")},
 
       // dummy collections
       ebSrFlagToken_{dummyProduces<EBSrFlagCollection>()},
       eeSrFlagToken_{dummyProduces<EESrFlagCollection>()},
 
       // dummy ECAL raw data collection
       ecalRawDataToken_{dummyProduces<EcalRawDataCollection>()},
 
       // dummy integrity for xtal data
       ebIntegrityGainErrorsToken_{dummyProduces<EBDetIdCollection>("EcalIntegrityGainErrors")},
       ebIntegrityGainSwitchErrorsToken_{dummyProduces<EBDetIdCollection>("EcalIntegrityGainSwitchErrors")},
       ebIntegrityChIdErrorsToken_{dummyProduces<EBDetIdCollection>("EcalIntegrityChIdErrors")},
 
       // dummy integrity for xtal data - EE specific (to be rivisited towards EB+EE common collection)
       eeIntegrityGainErrorsToken_{dummyProduces<EEDetIdCollection>("EcalIntegrityGainErrors")},
       eeIntegrityGainSwitchErrorsToken_{dummyProduces<EEDetIdCollection>("EcalIntegrityGainSwitchErrors")},
       eeIntegrityChIdErrorsToken_{dummyProduces<EEDetIdCollection>("EcalIntegrityChIdErrors")},
 
       // dummy integrity errors
       integrityTTIdErrorsToken_{dummyProduces<EcalElectronicsIdCollection>("EcalIntegrityTTIdErrors")},
       integrityZSXtalIdErrorsToken_{dummyProduces<EcalElectronicsIdCollection>("EcalIntegrityZSXtalIdErrors")},
       integrityBlockSizeErrorsToken_{dummyProduces<EcalElectronicsIdCollection>("EcalIntegrityBlockSizeErrors")},
 
       //
       pnDiodeDigisToken_{dummyProduces<EcalPnDiodeDigiCollection>()},
 
       // dummy TCC collections
       ecalTriggerPrimitivesToken_{dummyProduces<EcalTrigPrimDigiCollection>("EcalTriggerPrimitives")},
       ecalPseudoStripInputsToken_{dummyProduces<EcalPSInputDigiCollection>("EcalPseudoStripInputs")},
 
       // dummy mem integrity collections
       ecalIntegrityMemTtIdErrorsToken_{dummyProduces<EcalElectronicsIdCollection>("EcalIntegrityMemTtIdErrors")},
       ecalIntegrityMemBlockSizeErrorsToken_{
           dummyProduces<EcalElectronicsIdCollection>("EcalIntegrityMemBlockSizeErrors")},
       ecalIntegrityMemChIdErrorsToken_{dummyProduces<EcalElectronicsIdCollection>("EcalIntegrityMemChIdErrors")},
       ecalIntegrityMemGainErrorsToken_{dummyProduces<EcalElectronicsIdCollection>("EcalIntegrityMemGainErrors")} {}

◆ ~EcalDigisFromPortableProducer()

EcalDigisFromPortableProducer::~EcalDigisFromPortableProducer ( )

overridedefault

Member Function Documentation

◆ dummyProduces()

template<typename ProductType , typename... ARGS>

edm::EDPutTokenT<ProductType> EcalDigisFromPortableProducer::dummyProduces ( ARGS &&... args )

inlineprivate

Definition at line 25 of file EcalDigisFromPortableProducer.cc.

References writedatasetfile::args, and produceDummyIntegrityCollections_.

                                                             {
     return (produceDummyIntegrityCollections_) ? produces<ProductType>(std::forward<ARGS>(args)...)
                                                : edm::EDPutTokenT<ProductType>{};
   }

◆ fillDescriptions()

void EcalDigisFromPortableProducer::fillDescriptions ( edm::ConfigurationDescriptions & confDesc )

static

Definition at line 78 of file EcalDigisFromPortableProducer.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                            {
   edm::ParameterSetDescription desc;
 
   desc.add<edm::InputTag>("digisInLabelEB", edm::InputTag{"ecalRawToDigiPortable", "ebDigis"});
   desc.add<edm::InputTag>("digisInLabelEE", edm::InputTag{"ecalRawToDigiPortable", "eeDigis"});
   desc.add<std::string>("digisOutLabelEB", "ebDigis");
   desc.add<std::string>("digisOutLabelEE", "eeDigis");
   desc.add<bool>("produceDummyIntegrityCollections", false);
 
   confDesc.add("ecalDigisFromPortableProducer", desc);
 }

◆ produce()

void EcalDigisFromPortableProducer::produce	(	edm::Event &	event,
		edm::EventSetup const &	setup
	)

overrideprivate

Definition at line 138 of file EcalDigisFromPortableProducer.cc.

References digisInEBToken_, digisInEEToken_, digisOutEBToken_, digisOutEEToken_, ebIntegrityChIdErrorsToken_, ebIntegrityGainErrorsToken_, ebIntegrityGainSwitchErrorsToken_, ebSrFlagToken_, ecalIntegrityMemBlockSizeErrorsToken_, ecalIntegrityMemChIdErrorsToken_, ecalIntegrityMemGainErrorsToken_, ecalIntegrityMemTtIdErrorsToken_, ecalPseudoStripInputsToken_, ecalRawDataToken_, ecalTriggerPrimitivesToken_, eeIntegrityChIdErrorsToken_, eeIntegrityGainErrorsToken_, eeIntegrityGainSwitchErrorsToken_, eeSrFlagToken_, integrityBlockSizeErrorsToken_, integrityTTIdErrorsToken_, integrityZSXtalIdErrorsToken_, eostools::move(), pnDiodeDigisToken_, produceDummyIntegrityCollections_, and ecalPh1::sampleSize.

                                                                                        {
   // output collections
   auto digisEB = std::make_unique<EBDigiCollection>();
   auto digisEE = std::make_unique<EEDigiCollection>();
 
   auto const& digisEBSoAHostColl = event.get(digisInEBToken_);
   auto const& digisEESoAHostColl = event.get(digisInEEToken_);
   auto& digisEBSoAView = digisEBSoAHostColl.view();
   auto& digisEESoAView = digisEESoAHostColl.view();
 
   auto const digisEBSize = digisEBSoAView.size();
   auto const digisEESize = digisEESoAView.size();
   auto const digisEBDataSize = digisEBSize * ecalPh1::sampleSize;
   auto const digisEEDataSize = digisEESize * ecalPh1::sampleSize;
 
   // Intermediate containers because the DigiCollection containers are accessible only as const
   EBDigiCollection::IdContainer digisIdsEB;
   EEDigiCollection::IdContainer digisIdsEE;
   EBDigiCollection::DataContainer digisDataEB;
   EEDigiCollection::DataContainer digisDataEE;
 
   digisIdsEB.resize(digisEBSize);
   digisIdsEE.resize(digisEESize);
   digisDataEB.resize(digisEBDataSize);
   digisDataEE.resize(digisEEDataSize);
 
   // copy data
   std::memcpy(digisIdsEB.data(), digisEBSoAView.id(), digisEBSize * sizeof(uint32_t));
   std::memcpy(digisIdsEE.data(), digisEESoAView.id(), digisEESize * sizeof(uint32_t));
   std::memcpy(digisDataEB.data(), digisEBSoAView.data()->data(), digisEBDataSize * sizeof(uint16_t));
   std::memcpy(digisDataEE.data(), digisEESoAView.data()->data(), digisEEDataSize * sizeof(uint16_t));
 
   digisEB->swap(digisIdsEB, digisDataEB);
   digisEE->swap(digisIdsEE, digisDataEE);
 
   digisEB->sort();
   digisEE->sort();
 
   event.put(digisOutEBToken_, std::move(digisEB));
   event.put(digisOutEEToken_, std::move(digisEE));
 
   if (produceDummyIntegrityCollections_) {
     // dummy collections
     event.emplace(ebSrFlagToken_);
     event.emplace(eeSrFlagToken_);
     // dummy ECAL raw data collection
     event.emplace(ecalRawDataToken_);
     // dummy integrity for xtal data
     event.emplace(ebIntegrityGainErrorsToken_);
     event.emplace(ebIntegrityGainSwitchErrorsToken_);
     event.emplace(ebIntegrityChIdErrorsToken_);
     // dummy integrity for xtal data - EE specific (to be rivisited towards EB+EE common collection)
     event.emplace(eeIntegrityGainErrorsToken_);
     event.emplace(eeIntegrityGainSwitchErrorsToken_);
     event.emplace(eeIntegrityChIdErrorsToken_);
     // dummy integrity errors
     event.emplace(integrityTTIdErrorsToken_);
     event.emplace(integrityZSXtalIdErrorsToken_);
     event.emplace(integrityBlockSizeErrorsToken_);
     //
     event.emplace(pnDiodeDigisToken_);
     // dummy TCC collections
     event.emplace(ecalTriggerPrimitivesToken_);
     event.emplace(ecalPseudoStripInputsToken_);
     // dummy mem integrity collections
     event.emplace(ecalIntegrityMemTtIdErrorsToken_);
     event.emplace(ecalIntegrityMemBlockSizeErrorsToken_);
     event.emplace(ecalIntegrityMemChIdErrorsToken_);
     event.emplace(ecalIntegrityMemGainErrorsToken_);
   }
 }