Inheritance diagram for EcalBarrelClusterFastTimer:

Public Member Functions
	EcalBarrelClusterFastTimer (const edm::ParameterSet &)

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

	~EcalBarrelClusterFastTimer ()

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

Public Member Functions inherited from edm::global::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
float	correctTimeToVertex (const float intime, const DetId &timeDet, const reco::Vertex &vtx, const CaloSubdetectorGeometry *ecalGeom) const

std::pair< float, DetId >	getTimeForECALPFCluster (const EcalRecHitCollection &, const reco::PFCluster &) const

Private Attributes
std::vector< std::unique_ptr< const ResolutionModel > >	_resolutions

edm::EDGetTokenT< std::vector< reco::PFCluster > >	ebClustersToken_

edm::EDGetTokenT< EcalRecHitCollection >	ebTimeHitsToken_

const unsigned	ecalDepth_

const float	minEnergy_

const float	minFraction_

Additional Inherited Members
Public Types inherited from edm::global::EDProducerBase
typedef EDProducerBase	ModuleType

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

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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 37 of file EcalBarrelClusterFastTimer.cc.

Constructor & Destructor Documentation

EcalBarrelClusterFastTimer::EcalBarrelClusterFastTimer ( const edm::ParameterSet & conf )

Definition at line 78 of file EcalBarrelClusterFastTimer.cc.

References _resolutions, Exception, reco::get(), edm::ParameterSet::getParameterSetVector(), dataset::name, ctppsDiamondLocalTracks_cfi::resolution, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                   :
   ebTimeHitsToken_(consumes<EcalRecHitCollection>( conf.getParameter<edm::InputTag>("ebTimeHits") ) ),
   ebClustersToken_(consumes<std::vector<reco::PFCluster> >( conf.getParameter<edm::InputTag>("ebClusters") ) ),
   minFraction_( conf.getParameter<double>("minFractionToConsider") ),
   minEnergy_(conf.getParameter<double>("minEnergyToConsider") ),
   ecalDepth_(conf.getParameter<double>("ecalDepth") )
 {
   // setup resolution models
   const std::vector<edm::ParameterSet>& resos = conf.getParameterSetVector("resolutionModels");
   for( const auto& reso : resos ) {
     const std::string& name = reso.getParameter<std::string>("modelName");
     ResolutionModel* resomod = ResolutionModelFactory::get()->create(name,reso);
     _resolutions.emplace_back( resomod );  
 
     // times and time resolutions for general tracks
     produces<edm::ValueMap<float> >(name); 
     produces<edm::ValueMap<float> >(name+resolution);    
   }
   // get RNG engine
   edm::Service<edm::RandomNumberGenerator> rng;
   if (!rng.isAvailable()){
     throw cms::Exception("Configuration")
       << "EcalBarrelClusterFastTimer::EcalBarrelClusterFastTimer() - RandomNumberGeneratorService is not present in configuration file.\n"
       << "Add the service in the configuration file or remove the modules that require it.";
   }
 }

EcalBarrelClusterFastTimer::~EcalBarrelClusterFastTimer ( )

inline

Definition at line 40 of file EcalBarrelClusterFastTimer.cc.

References produce().

40 { }

Member Function Documentation

float EcalBarrelClusterFastTimer::correctTimeToVertex	(	const float	intime,
		const DetId &	timeDet,
		const reco::Vertex &	vtx,
		const CaloSubdetectorGeometry *	ecalGeom
	)		const

private

Definition at line 176 of file EcalBarrelClusterFastTimer.cc.

References ecalDepth_, Exception, CaloSubdetectorGeometry::getGeometry(), reco::Vertex::position(), DetId::rawId(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                                                      {
   if( timeDet.rawId() == 0 ) return -999.;
   // correct the cluster time from 0,0,0 to the primary vertex given
   const CaloCellGeometry* cellGeometry ( ecalGeom->getGeometry( timeDet ) ) ;
   if( nullptr == cellGeometry ) {
     throw cms::Exception("BadECALBarrelCell")
       << timeDet << " is not a valid ECAL Barrel DetId!";
   }
   //depth in mm in the middle of the layer position;
   GlobalPoint layerPos = (dynamic_cast<const TruncatedPyramid*>(cellGeometry))->getPosition( ecalDepth_+0.5 ); 
   const math::XYZPoint layerPos_cm( layerPos.x(), layerPos.y(), layerPos.z() );
   const math::XYZVector to_center = layerPos_cm - math::XYZPoint(0.,0.,0.);
   const math::XYZVector to_vtx = layerPos_cm - vtx.position();
   
   /*
   std::cout << intime << ' ' << to_center.r()/cm_per_ns << ' ' << to_vtx.r()/cm_per_ns
             << ' ' << intime + to_center.r()/cm_per_ns - to_vtx.r()/cm_per_ns << std::endl;
   */
 
   return intime + to_center.r()/cm_per_ns - to_vtx.r()/cm_per_ns;
 }

std::pair< float, DetId > EcalBarrelClusterFastTimer::getTimeForECALPFCluster	(	const EcalRecHitCollection &	timehits,
		const reco::PFCluster &	cluster
	)		const

private

Definition at line 147 of file EcalBarrelClusterFastTimer.cc.

References edm::SortedCollection< T, SORT >::find(), dedxEstimators_cff::fraction, hpstanc_transforms::max, minEnergy_, minFraction_, and reco::PFCluster::recHitFractions().

Referenced by produce().

                                                                                                                                                  {
   
   const auto& rhfs = cluster.recHitFractions();  
   unsigned best_hit = 0;
   float best_energy = -1.f;
   for( const auto& rhf : rhfs ) {
     const auto& hitref = rhf.recHitRef();
     const unsigned detid = hitref->detId();
     const auto fraction = rhf.fraction();
     const auto energy = hitref->energy();
     if( fraction < minFraction_ || energy < minEnergy_ ) continue;
     auto timehit = timehits.find(detid);
     float e_hit = rhf.fraction() * hitref->energy();
     if( e_hit > best_energy && timehit->isTimeValid() ) {
       best_energy = e_hit;
       best_hit = detid;
     }
   }
   
   float best_time_guess = std::numeric_limits<float>::max();
   if( best_energy > 0. ) {
     best_time_guess = timehits.find(best_hit)->time();
   }
   
   //std::cout << "EcalBarrelFastTimer: " << best_time_guess << ' ' << best_energy << ' ' << best_hit << std::endl;
 
   return std::make_pair(best_time_guess,DetId(best_hit));
 }

void EcalBarrelClusterFastTimer::produce	(	edm::StreamID	sid,
		edm::Event &	evt,
		const edm::EventSetup &	es
	)		const

overridevirtual

Definition at line 105 of file EcalBarrelClusterFastTimer.cc.

References _resolutions, fastPrimaryVertexProducer_cfi::clusters, ebClustersToken_, ebTimeHitsToken_, plotBeamSpotDB::first, edm::Event::getByToken(), edm::RandomNumberGenerator::getEngine(), getTimeForECALPFCluster(), mps_fire::i, dataset::name, ctppsDiamondLocalTracks_cfi::resolution, electronProducer_cfi::resolutions, AlCaHLTBitMon_QueryRunRegistry::string, and create_public_lumi_plots::times.

Referenced by ~EcalBarrelClusterFastTimer().

                                                                                                       {
   // get RNG engine
   edm::Service<edm::RandomNumberGenerator> rng; 
   auto rng_engine = &(rng->getEngine(sid));
 
   edm::Handle<std::vector<reco::PFCluster> > clustersH;
   edm::Handle<EcalRecHitCollection> timehitsH;
 
   evt.getByToken(ebClustersToken_,clustersH);
   evt.getByToken(ebTimeHitsToken_,timehitsH);
   
   const auto& clusters = *clustersH;
   const auto& timehits = *timehitsH;
   
   std::vector<std::pair<float,DetId> > times; // perfect times keyed to cluster index
   times.reserve(clusters.size());
   
   for( const auto& cluster : clusters ) {
     times.push_back( getTimeForECALPFCluster( timehits, cluster ) );
   }
   
   for( const auto& reso : _resolutions ) {
     const std::string& name = reso->name();
     std::vector<float> resolutions;
     std::vector<float> smeared_times;
     resolutions.reserve(clusters.size());
     smeared_times.reserve(clusters.size());
     
     // smear once then correct to multiple vertices
     for( unsigned i = 0 ; i < clusters.size(); ++i ) {      
       const float theresolution = reso->getTimeResolution(clusters[i]);
       
       smeared_times.emplace_back( CLHEP::RandGauss::shoot(rng_engine, times[i].first, theresolution) );
       resolutions.push_back( theresolution );
     }    
 
     writeValueMap(evt,clustersH,smeared_times,name);
     writeValueMap(evt,clustersH,resolutions,name+resolution);
   }
 
 }