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

	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

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

edm::ESGetToken< ME0Geometry, MuonGeometryRecord >	geom_token_

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<>
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 41 of file ME0ReDigiProducer.cc.

Member Typedef Documentation

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

private

Definition at line 102 of file ME0ReDigiProducer.cc.

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

private

Definition at line 101 of file ME0ReDigiProducer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 268 of file ME0ReDigiProducer.cc.

References Exception, geometry, 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")))),
       geom_token_(esConsumes<ME0Geometry, MuonGeometryRecord, edm::Transition::BeginRun>()) {
   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 311 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 316 of file ME0ReDigiProducer.cc.

References ME0Geometry::chambers(), chambers, Exception, fillCentralTOFs(), geom_token_, geometry, edm::EventSetup::getHandle(), layerReadout, LogDebug, numberOfPartitions, numberOfStrips, ME0ReDigiProducer::TemporaryGeometry::numLayers(), tempGeo, useBuiltinGeo, and useCusGeoFor1PartGeo.

                                                                                {
   // set geometry
   edm::ESHandle<ME0Geometry> hGeom = eventSetup.getHandle(geom_token_);
   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 372 of file ME0ReDigiProducer.cc.

References bxWidth, ME0Geometry::etaPartition(), fillDigiMap(), geometry, getCustomStripProperties(), getStripProperties(), MuonDigiCollection< IndexType, DigiType >::insertDigi(), layerReadout, LogDebug, LogTrace, maxBXReadout, mergeDigis, minBXReadout, neutronAcceptance, sistrip::SpyUtilities::range(), BeamSpotPI::sigmaX, BeamSpotPI::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 478 of file ME0ReDigiProducer.cc.

References ME0Geometry::chambers(), Exception, geometry, phase1PixelTopology::layer, LogDebug, 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 557 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 501 of file ME0ReDigiProducer.cc.

References ME0ReDigiProducer::TemporaryGeometry::findEtaPartition(), 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 533 of file ME0ReDigiProducer.cc.

References 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 354 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));
 }