#include <ME0ReDigiProducer.h>

Inheritance diagram for ME0ReDigiProducer:

Classes
class	TemporaryGeometry

Public Member Functions
void	beginRun (const edm::Run &, const edm::EventSetup &) override

void	buildDigis (const ME0DigiPreRecoCollection &, ME0DigiPreRecoCollection &, ME0DigiPreRecoMap &, CLHEP::HepRandomEngine *engine)

	ME0ReDigiProducer (const edm::ParameterSet &ps)

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

	~ME0ReDigiProducer () override

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

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

Private Types
typedef std::map< DigiIndicies, unsigned int >	ChamberDigiMap

typedef std::tuple< unsigned int, unsigned int, unsigned int >	DigiIndicies

Private Member Functions
void	fillCentralTOFs ()

unsigned int	fillDigiMap (ChamberDigiMap &chDigiMap, unsigned int bx, unsigned int part, unsigned int strip, unsigned int currentIDX) const

int	getCustomStripProperties (const ME0DetId &detId, const ME0DigiPreReco *inDigi, float &tof, int &strip, LocalPoint &digiLocalPoint, LocalError &digiLocalError) const

void	getStripProperties (const ME0EtaPartition etaPart, const ME0DigiPreReco inDigi, float &tof, int &strip, LocalPoint &digiLocalPoint, LocalError &digiLocalError) const

Private Attributes
const float	bxWidth

const ME0Geometry *	geometry

std::vector< int >	layerReadout

int	maxBXReadout

bool	mergeDigis

int	minBXReadout

double	neutronAcceptance

unsigned int	numberOfPartitions

unsigned int	numberOfStrips

TemporaryGeometry *	tempGeo

double	timeResolution

std::vector< std::vector< double > >	tofs

edm::EDGetTokenT< ME0DigiPreRecoCollection >	token

bool	useBuiltinGeo

bool	useCusGeoFor1PartGeo

bool	usePads

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

Definition at line 29 of file ME0ReDigiProducer.h.

Member Typedef Documentation

typedef std::map<DigiIndicies,unsigned int> ME0ReDigiProducer::ChamberDigiMap

private

Definition at line 77 of file ME0ReDigiProducer.h.

typedef std::tuple<unsigned int, unsigned int, unsigned int> ME0ReDigiProducer::DigiIndicies

private

Definition at line 76 of file ME0ReDigiProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 136 of file ME0ReDigiProducer.cc.

References Exception, neutronAcceptance, numberOfPartitions, numberOfStrips, tempGeo, useBuiltinGeo, useCusGeoFor1PartGeo, and usePads.

                                                               :
         bxWidth            (25.0),
         useCusGeoFor1PartGeo(ps.getParameter<bool>("useCusGeoFor1PartGeo")),
         usePads(ps.getParameter<bool>("usePads")),
         numberOfStrips      (ps.getParameter<unsigned int>("numberOfStrips")),
         numberOfPartitions (ps.getParameter<unsigned int>("numberOfPartitions")),
         neutronAcceptance  (ps.getParameter<double>("neutronAcceptance")),
         timeResolution     (ps.getParameter<double>("timeResolution")),
         minBXReadout       (ps.getParameter<int>("minBXReadout")),
         maxBXReadout       (ps.getParameter<int>("maxBXReadout")),
         layerReadout       (ps.getParameter<std::vector<int>>("layerReadout")),
         mergeDigis         (ps.getParameter<bool>("mergeDigis")),
         token(consumes<ME0DigiPreRecoCollection>(edm::InputTag(ps.getParameter<std::string>("inputCollection"))))
 {
     produces<ME0DigiPreRecoCollection>();
     produces<ME0DigiPreRecoMap>();
 
     edm::Service<edm::RandomNumberGenerator> rng;
     if (!rng.isAvailable()){
         throw cms::Exception("Configuration")
         << "ME0ReDigiProducer::ME0PreRecoDigiProducer() - RandomNumberGeneratorService is not present in configuration file.\n"
         << "Add the service in the configuration file or remove the modules that require it.";
     }
     geometry = nullptr;
     tempGeo = nullptr;
     useBuiltinGeo = true;
 
     if(useCusGeoFor1PartGeo){
             if (usePads)
                 numberOfStrips = numberOfStrips/2;
         if(numberOfStrips == 0)
             throw cms::Exception("Setup") << "ME0ReDigiProducer::ME0PreRecoDigiProducer() - Must have at least one strip if using custom geometry.";
         if(numberOfPartitions == 0)
             throw cms::Exception("Setup") << "ME0ReDigiProducer::ME0PreRecoDigiProducer() - Must have at least one partition if using custom geometry.";
     }
 
     if(neutronAcceptance < 0 )
         throw cms::Exception("Setup") << "ME0ReDigiProducer::ME0PreRecoDigiProducer() - neutronAcceptance must be >= 0.";
 }

ME0ReDigiProducer::~ME0ReDigiProducer ( )

override

Definition at line 177 of file ME0ReDigiProducer.cc.

References tempGeo.

 {
     if(tempGeo) delete tempGeo;
 }

Member Function Documentation

void ME0ReDigiProducer::beginRun	(	const edm::Run &	,
		const edm::EventSetup &	eventSetup
	)

override

Definition at line 183 of file ME0ReDigiProducer.cc.

References chambers, Exception, fillCentralTOFs(), edm::EventSetup::get(), layerReadout, LogDebug, MuonTCMETValueMapProducer_cff::nLayers, numberOfPartitions, numberOfStrips, ME0ReDigiProducer::TemporaryGeometry::numLayers(), tempGeo, useBuiltinGeo, and useCusGeoFor1PartGeo.

 {
     // set geometry
     edm::ESHandle<ME0Geometry> hGeom;
     eventSetup.get<MuonGeometryRecord>().get(hGeom);
     geometry= &*hGeom;
 
     const auto& chambers = geometry->chambers();
     if(chambers.empty())
         throw cms::Exception("Setup") << "ME0ReDigiProducer::beginRun() - No ME0Chambers in geometry.";
 
     const unsigned int nLayers = chambers.front()->nLayers();
     if(!nLayers) throw cms::Exception("Setup") << "ME0ReDigiProducer::beginRun() - No layers in ME0 geometry.";
 
     const unsigned int nPartitions = chambers.front()->layers()[0]->nEtaPartitions();
 
     if(useCusGeoFor1PartGeo && nPartitions == 1){
         useBuiltinGeo = false;
     }
 
     if(useBuiltinGeo){
         if(nLayers != layerReadout.size() )
             throw cms::Exception("Configuration") << "ME0ReDigiProducer::beginRun() - The geometry has "<<nLayers
             << " layers, but the readout of "<<layerReadout.size() << " were specified with the layerReadout parameter."  ;
         fillCentralTOFs();
     } else {
         LogDebug("ME0ReDigiProducer")
                 << "Building temporary geometry:" << std::endl;
         tempGeo = new TemporaryGeometry(geometry,numberOfStrips,numberOfPartitions);
         LogDebug("ME0ReDigiProducer")
         << "Done building temporary geometry!" << std::endl;
 
         if(tempGeo->numLayers() != layerReadout.size() )
             throw cms::Exception("Configuration") << "ME0ReDigiProducer::beginRun() - The geometry has "<<tempGeo->numLayers()
             << " layers, but the readout of "<<layerReadout.size() << " were specified with the layerReadout parameter."  ;
     }
 }

void ME0ReDigiProducer::buildDigis	(	const ME0DigiPreRecoCollection &	input_digis,
		ME0DigiPreRecoCollection &	output_digis,
		ME0DigiPreRecoMap &	output_digimap,
		CLHEP::HepRandomEngine *	engine
	)

Definition at line 245 of file ME0ReDigiProducer.cc.

References bxWidth, fillDigiMap(), getCustomStripProperties(), getStripProperties(), MuonDigiCollection< IndexType, DigiType >::insertDigi(), layerReadout, LogDebug, LogTrace, maxBXReadout, mergeDigis, minBXReadout, neutronAcceptance, fftjetvertexadder_cfi::sigmaX, fftjetvertexadder_cfi::sigmaY, mathSSE::sqrt(), digitizers_cfi::strip, timeResolution, useBuiltinGeo, PV3DBase< T, PVType, FrameType >::x(), LocalError::xx(), LocalError::xy(), PV3DBase< T, PVType, FrameType >::y(), and LocalError::yy().

Referenced by produce().

 {
 
     /*
       Starting form the incoming pseudo-digi, which has perfect time and position resolution:
       1A. Smear time using sigma_t by some value
       1B. Correct the smeared time with the central arrival time for partition
       1C. Apply discretization: if the smeared time is outside the BX window (-12.5ns;+12.5ns),
       the hit should be assigned to the next (or previous) BX
 
       2A. Find strip that the digi belongs to
       2B. Get the center of this strip and the error on the position assuming the geometry
 
       3A. Filter event if a digi at this partition/strip/BX already exists
       3B. Add to collection
     */
 
     LogDebug("ME0ReDigiProducer::buildDigis") << "Begin building digis."<<std::endl;
     ME0DigiPreRecoCollection::DigiRangeIterator me0dgIt;
     for (me0dgIt = input_digis.begin(); me0dgIt != input_digis.end();
             ++me0dgIt){
 
         const auto& me0Id = (*me0dgIt).first;
         LogTrace("ME0ReDigiProducer::buildDigis") << "Starting with roll: "<< me0Id<<std::endl;
 
         //setup map for this chamber/eta partition
         ChamberDigiMap chDigiMap;
 
         int newDigiIdx = 0;
         const ME0DigiPreRecoCollection::Range& range = (*me0dgIt).second;
         for (ME0DigiPreRecoCollection::const_iterator digi = range.first;
                 digi != range.second;digi++) {
             LogTrace("ME0ReDigiProducer::buildDigis") << std::endl<< "(" <<digi->x() <<","<< digi->y()<<","<<digi->tof()<<","<<digi->pdgid()<<","<<digi->prompt()<<")-> ";
 
             //If we don't readout this layer skip
             if(!layerReadout[me0Id.layer() -1 ]) {
                 output_digimap.insertDigi(me0Id, -1);
                 continue;
             }
 
             //if neutron and we are filtering skip
             if(!digi->prompt() && neutronAcceptance < 1.0 )
                 if (CLHEP::RandFlat::shoot(engine) > neutronAcceptance){
                     output_digimap.insertDigi(me0Id, -1);
                     continue;
                 }
 
             //smear TOF if necessary
             float tof = digi->tof() + (timeResolution < 0 ? 0.0 : CLHEP::RandGaussQ::shoot(engine, 0, timeResolution));
 
             //Values used to fill objet
             int mapPartIDX = me0Id.roll() -1;
             int strip = 0;
             LocalPoint  digiLocalPoint;
             LocalError  digiLocalError;
             if(useBuiltinGeo){
                 getStripProperties(geometry->etaPartition(me0Id),&*digi,tof,strip,digiLocalPoint,digiLocalError);
             } else {
                 mapPartIDX = getCustomStripProperties(me0Id,&*digi,tof,strip,digiLocalPoint,digiLocalError);
 
             }
 
             //filter if outside of readout window
             const int bxIdx = std::round(tof/bxWidth);
             LogTrace("ME0ReDigiProducer::buildDigis") << tof <<"("<<bxIdx<<") ";
             if(bxIdx < minBXReadout) {output_digimap.insertDigi(me0Id, -1); continue; }
             if(bxIdx > maxBXReadout) {output_digimap.insertDigi(me0Id, -1); continue; }
             tof = bxIdx*bxWidth;
 
 
             //If we are merging check to see if it already exists
             LogTrace("ME0ReDigiProducer::buildDigis") << "("<<bxIdx<<","<<mapPartIDX<<","<<strip<<") ";
             if(mergeDigis){
                 int matchIDX = fillDigiMap(chDigiMap, bxIdx,mapPartIDX,strip,newDigiIdx);
                 if(matchIDX >= 0){
                     output_digimap.insertDigi(me0Id, matchIDX);
                     continue;
                 }
             }
 
             //Digis store sigmaX,sigmaY, correlationCoef
             const float sigmaX = std::sqrt(digiLocalError.xx());
             const float sigmaY = std::sqrt(digiLocalError.yy());
             const float corrCoef = digiLocalError.xy() /(sigmaX*sigmaY);
 
             //Fill in the new collection
             ME0DigiPreReco out_digi(digiLocalPoint.x(), digiLocalPoint.y(),
                     sigmaX, sigmaY, corrCoef, tof, digi->pdgid(), digi->prompt());
             output_digis.insertDigi(me0Id, out_digi);
 
             // store index of previous detid and digi
             output_digimap.insertDigi(me0Id, newDigiIdx);
             newDigiIdx++;
 
             LogTrace("ME0ReDigiProducer::buildDigis") << "("<<digiLocalPoint.x()<<","<<digiLocalPoint.y()<<","<<sigmaX<<","<<sigmaY<<","<< tof<<") ";
         }
 
         chDigiMap.clear();
 
 
     }
 
 }

void ME0ReDigiProducer::fillCentralTOFs ( )

private

Definition at line 352 of file ME0ReDigiProducer.cc.

References Exception, LogDebug, MuonTCMETValueMapProducer_cff::nLayers, and tofs.

Referenced by beginRun().

                                         {
     const auto* mainChamber = geometry->chambers().front();
     const unsigned int nLayers = mainChamber->nLayers();
     //Get TOF at center of each partition
     tofs.clear();
     tofs.resize(nLayers);
     LogDebug("ME0ReDigiProducer::fillCentralTOFs()") << "TOF numbers [layer][partition]: " ;
     for(unsigned int iL = 0; iL < nLayers; ++iL){
         const auto* layer = mainChamber->layers()[iL];
         const unsigned int mapLayIDX = layer->id().layer() -1;
         const unsigned int nPartitions = layer->nEtaPartitions();
         if(!nPartitions)
             throw cms::Exception("Setup") << "ME0ReDigiProducer::fillCentralTOFs() - ME0Layer has no partitions.";
         tofs[mapLayIDX].resize(nPartitions);
         for(unsigned int iP = 0; iP < nPartitions; ++iP){
             const unsigned int mapPartIDX = layer->etaPartitions()[iP]->id().roll() -1;
             const GlobalPoint centralGP(layer->etaPartitions()[iP]->position());
             tofs[mapLayIDX][mapPartIDX] = (centralGP.mag() / (CLHEP::c_light/CLHEP::cm)); //speed of light [cm/ns]
             LogDebug("ME0ReDigiProducer::fillCentralTOFs()") << "["<<mapLayIDX<<"]["<<mapPartIDX<<"]="<< tofs[mapLayIDX][mapPartIDX] <<" "<<std::endl;
         }
     }
 }

unsigned int ME0ReDigiProducer::fillDigiMap	(	ChamberDigiMap &	chDigiMap,
		unsigned int	bx,
		unsigned int	part,
		unsigned int	strip,
		unsigned int	currentIDX
	)		const

private

Definition at line 417 of file ME0ReDigiProducer.cc.

Referenced by buildDigis().

                                                                                                                                                             {
     DigiIndicies newIDX(bx,part,strip);
     auto it1 = chDigiMap.find(newIDX);
     if (it1 == chDigiMap.end()){
         chDigiMap[newIDX] = currentIDX;
         return -1;
     }
     return it1->second;
 }

int ME0ReDigiProducer::getCustomStripProperties	(	const ME0DetId &	detId,
		const ME0DigiPreReco *	inDigi,
		float &	tof,
		int &	strip,
		LocalPoint &	digiLocalPoint,
		LocalError &	digiLocalError
	)		const

private

Definition at line 374 of file ME0ReDigiProducer.cc.

References ME0ReDigiProducer::TemporaryGeometry::findEtaPartition(), objects.autophobj::float, ME0ReDigiProducer::TemporaryGeometry::getCentralTOF(), ME0ReDigiProducer::TemporaryGeometry::getPartCenter(), ME0ReDigiProducer::TemporaryGeometry::getTopo(), LogTrace, partIdx(), mathSSE::sqrt(), tempGeo, ME0DigiPreReco::x(), PV3DBase< T, PVType, FrameType >::x(), ME0DigiPreReco::y(), and PV3DBase< T, PVType, FrameType >::y().

Referenced by buildDigis().

                                                                                                                                                                                            {
     const unsigned int partIdx = tempGeo->findEtaPartition(inDigi->y());
     LogTrace("ME0ReDigiProducer::buildDigis") << partIdx <<" ";
     const float partMeanTof = tempGeo->getCentralTOF(detId,partIdx);
 
     //convert to relative to partition
     tof -= partMeanTof;
 
     //get coordinates and errors
     const float partCenter = tempGeo->getPartCenter(partIdx);
     const auto* topo = tempGeo->getTopo(partIdx);
 
     //find channel
     const LocalPoint partLocalPoint(inDigi->x(), inDigi->y() - partCenter ,0.);
     strip = topo->channel(partLocalPoint);
     const float stripF = float(strip)+0.5;
 
     //get digitized location
     LocalPoint  digiPartLocalPoint = topo->localPosition(stripF);
     digiLocalError = topo->localError(stripF, 1./sqrt(12.)); //std dev. flat distribution with length L is L/sqrt(12). The strip topology expects the error in units of strips.
     digiLocalPoint = LocalPoint(digiPartLocalPoint.x(),digiPartLocalPoint.y() + partCenter,0.0);
     return partIdx;
 
 
 }

void ME0ReDigiProducer::getStripProperties	(	const ME0EtaPartition *	etaPart,
		const ME0DigiPreReco *	inDigi,
		float &	tof,
		int &	strip,
		LocalPoint &	digiLocalPoint,
		LocalError &	digiLocalError
	)		const

private

Definition at line 399 of file ME0ReDigiProducer.cc.

References objects.autophobj::float, ME0EtaPartition::id(), ME0DetId::layer(), TrapezoidalStripTopology::nstrips(), TrapezoidalStripTopology::pitch(), TrapezoidalStripTopology::radius(), ME0DetId::roll(), ME0EtaPartition::specificTopology(), mathSSE::sqrt(), TrapezoidalStripTopology::stripLength(), tofs, usePads, ME0DigiPreReco::x(), and ME0DigiPreReco::y().

Referenced by buildDigis().

                                                                                                                                                                                               {
     //convert to relative to partition
     tof -= tofs[etaPart->id().layer()-1][etaPart->id().roll() -1];
 
     const TrapezoidalStripTopology * origTopo = (const TrapezoidalStripTopology*)(&etaPart->specificTopology());
     TrapezoidalStripTopology padTopo(origTopo->nstrips()/2,origTopo->pitch()*2,origTopo->stripLength(),origTopo->radius());
     const auto & topo = usePads ?  padTopo : etaPart->specificTopology();
 
     //find channel
     const LocalPoint partLocalPoint(inDigi->x(), inDigi->y(),0.);
     strip = topo.channel(partLocalPoint);
     const float stripF = float(strip)+0.5;
 
     //get digitized location
     digiLocalPoint = topo.localPosition(stripF);
     digiLocalError = topo.localError(stripF, 1./sqrt(12.));
 }

void ME0ReDigiProducer::produce	(	edm::Event &	e,
		const edm::EventSetup &	eventSetup
	)

override

Definition at line 222 of file ME0ReDigiProducer.cc.

References buildDigis(), edm::Event::getByToken(), edm::RandomNumberGenerator::getEngine(), eostools::move(), edm::Handle< T >::product(), edm::Event::put(), edm::Event::streamID(), and token.

 {
     edm::Service<edm::RandomNumberGenerator> rng;
     CLHEP::HepRandomEngine* engine = &rng->getEngine(e.streamID());
 
     edm::Handle<ME0DigiPreRecoCollection> input_digis;
     e.getByToken(token, input_digis);
 
     std::unique_ptr<ME0DigiPreRecoCollection> output_digis(new ME0DigiPreRecoCollection());
     std::unique_ptr<ME0DigiPreRecoMap>       output_digimap(new ME0DigiPreRecoMap());
 
     // build the digis
     buildDigis(*(input_digis.product()),
             *output_digis,
             *output_digimap,
             engine);
 
     // store them in the event
     e.put(std::move(output_digis));
     e.put(std::move(output_digimap));
 }