#include <EcalDetailedTimeRecHitProducer.h>

Inheritance diagram for EcalDetailedTimeRecHitProducer:

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

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

	~EcalDetailedTimeRecHitProducer () 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 Member Functions
double	deltaTimeOfFlight (GlobalPoint &vertex, const DetId &detId, int layer) const

Private Attributes
edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	caloGeometry_

bool	correctForVertexZPosition_

std::string	EBDetailedTimeRecHitCollection_

edm::EDGetTokenT< EBRecHitCollection >	EBRecHitCollection_

edm::EDGetTokenT< EcalTimeDigiCollection >	ebTimeDigiCollection_

int	ebTimeLayer_

std::string	EEDetailedTimeRecHitCollection_

edm::EDGetTokenT< EERecHitCollection >	EERecHitCollection_

edm::EDGetTokenT< EcalTimeDigiCollection >	eeTimeDigiCollection_

int	eeTimeLayer_

const CaloGeometry *	m_geometry

edm::EDGetTokenT< reco::VertexCollection >	recoVertex_

edm::EDGetTokenT< edm::SimVertexContainer >	simVertex_

bool	useMCTruthVertex_

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

produce ECAL detailed time Rechits

Author: Paolo Meridiani

produce ECAL rechits associating them with improved ecalTimeDigis

Author: Paolo Meridiani, INFN Roma

Definition at line 29 of file EcalDetailedTimeRecHitProducer.h.

Constructor & Destructor Documentation

◆ EcalDetailedTimeRecHitProducer()

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

explicit

Definition at line 42 of file EcalDetailedTimeRecHitProducer.cc.

                                                                                         : m_geometry(nullptr) {
   EBRecHitCollection_ = consumes<EBRecHitCollection>(ps.getParameter<edm::InputTag>("EBRecHitCollection"));
   EERecHitCollection_ = consumes<EERecHitCollection>(ps.getParameter<edm::InputTag>("EERecHitCollection"));
  
   ebTimeDigiCollection_ = consumes<EcalTimeDigiCollection>(ps.getParameter<edm::InputTag>("EBTimeDigiCollection"));
   eeTimeDigiCollection_ = consumes<EcalTimeDigiCollection>(ps.getParameter<edm::InputTag>("EETimeDigiCollection"));
  
   caloGeometry_ = esConsumes<CaloGeometry, CaloGeometryRecord>();
  
   EBDetailedTimeRecHitCollection_ = ps.getParameter<std::string>("EBDetailedTimeRecHitCollection");
   EEDetailedTimeRecHitCollection_ = ps.getParameter<std::string>("EEDetailedTimeRecHitCollection");
  
   correctForVertexZPosition_ = ps.getParameter<bool>("correctForVertexZPosition");
   useMCTruthVertex_ = ps.getParameter<bool>("useMCTruthVertex");
   if (correctForVertexZPosition_) {
     if (not useMCTruthVertex_) {
       recoVertex_ = consumes<reco::VertexCollection>(ps.getParameter<edm::InputTag>("recoVertex"));
     } else {
       simVertex_ = consumes<edm::SimVertexContainer>(ps.getParameter<edm::InputTag>("simVertex"));
     }
   }
  
   ebTimeLayer_ = ps.getParameter<int>("EBTimeLayer");
   eeTimeLayer_ = ps.getParameter<int>("EETimeLayer");
  
   produces<EBRecHitCollection>(EBDetailedTimeRecHitCollection_);
   produces<EERecHitCollection>(EEDetailedTimeRecHitCollection_);
 }

References caloGeometry_, correctForVertexZPosition_, EBDetailedTimeRecHitCollection_, EBRecHitCollection_, ebTimeDigiCollection_, ebTimeLayer_, EEDetailedTimeRecHitCollection_, EERecHitCollection_, eeTimeDigiCollection_, eeTimeLayer_, edm::ParameterSet::getParameter(), recoVertex_, simVertex_, AlCaHLTBitMon_QueryRunRegistry::string, and useMCTruthVertex_.

◆ ~EcalDetailedTimeRecHitProducer()

EcalDetailedTimeRecHitProducer::~EcalDetailedTimeRecHitProducer ( )

override

Definition at line 71 of file EcalDetailedTimeRecHitProducer.cc.

71 {}

Member Function Documentation

◆ deltaTimeOfFlight()

double EcalDetailedTimeRecHitProducer::deltaTimeOfFlight	(	GlobalPoint &	vertex,
		const DetId &	detId,
		int	layer
	)		const

private

Definition at line 208 of file EcalDetailedTimeRecHitProducer.cc.

                                                                                                                  {
   auto cellGeometry(m_geometry->getGeometry(detId));
   assert(nullptr != cellGeometry);
   GlobalPoint layerPos =
       cellGeometry->getPosition(double(layer) + 0.5);  //depth in mm in the middle of the layer position
   GlobalVector tofVector = layerPos - vertex;
   return (layerPos.mag() * cm - tofVector.mag() * cm) / (float)c_light;
 }

References cms::cuda::assert(), CaloGeometry::getGeometry(), phase1PixelTopology::layer, m_geometry, PV3DBase< T, PVType, FrameType >::mag(), and bphysicsOniaDQM_cfi::vertex.

Referenced by produce().

◆ produce()

void EcalDetailedTimeRecHitProducer::produce	(	edm::Event &	evt,
		const edm::EventSetup &	es
	)

override

Definition at line 73 of file EcalDetailedTimeRecHitProducer.cc.

                                                                                    {
   using namespace edm;
   using namespace reco;
  
   edm::ESHandle<CaloGeometry> hGeometry = es.getHandle(caloGeometry_);
  
   m_geometry = hGeometry.product();
  
   Handle<EBRecHitCollection> pEBRecHits;
   Handle<EERecHitCollection> pEERecHits;
  
   const EBRecHitCollection* EBRecHits = nullptr;
   const EERecHitCollection* EERecHits = nullptr;
  
   evt.getByToken(EBRecHitCollection_, pEBRecHits);
   if (pEBRecHits.isValid()) {
     EBRecHits = pEBRecHits.product();  // get a ptr to the product
 #ifdef DEBUG
     LogDebug("EcalRecHitDebug") << "total # EB rechits to be re-calibrated: " << EBRecHits->size();
 #endif
   }
  
   evt.getByToken(EERecHitCollection_, pEERecHits);
   if (pEERecHits.isValid()) {
     EERecHits = pEERecHits.product();  // get a ptr to the product
 #ifdef DEBUG
     LogDebug("EcalRecHitDebug") << "total # EE uncalibrated rechits to be re-calibrated: " << EERecHits->size();
 #endif
   }
  
   Handle<EcalTimeDigiCollection> pEBTimeDigis;
   Handle<EcalTimeDigiCollection> pEETimeDigis;
  
   const EcalTimeDigiCollection* ebTimeDigis = nullptr;
   const EcalTimeDigiCollection* eeTimeDigis = nullptr;
  
   evt.getByToken(ebTimeDigiCollection_, pEBTimeDigis);
   //evt.getByToken( digiProducer_, pEBTimeDigis);
   if (pEBTimeDigis.isValid()) {
     ebTimeDigis = pEBTimeDigis.product();  // get a ptr to the produc
     edm::LogInfo("EcalDetailedTimeRecHitInfo") << "total # ebTimeDigis: " << ebTimeDigis->size();
   }
  
   evt.getByToken(eeTimeDigiCollection_, pEETimeDigis);
   //evt.getByToken( digiProducer_, pEETimeDigis);
   if (pEETimeDigis.isValid()) {
     eeTimeDigis = pEETimeDigis.product();  // get a ptr to the product
     edm::LogInfo("EcalDetailedTimeRecHitInfo") << "total # eeTimeDigis: " << eeTimeDigis->size();
   }
   // collection of rechits to put in the event
   std::unique_ptr<EBRecHitCollection> EBDetailedTimeRecHits(new EBRecHitCollection);
   std::unique_ptr<EERecHitCollection> EEDetailedTimeRecHits(new EERecHitCollection);
  
   std::unique_ptr<GlobalPoint> vertex;
  
   if (correctForVertexZPosition_) {
     if (!useMCTruthVertex_) {
       //Get the first reco vertex
       // get primary vertices
  
       edm::Handle<VertexCollection> VertexHandle;
       evt.getByToken(recoVertex_, VertexHandle);
  
       if (VertexHandle.isValid()) {
         if (!(*VertexHandle).empty())  //at least 1 vertex
         {
           const reco::Vertex* myVertex = &(*VertexHandle)[0];
           vertex = std::make_unique<GlobalPoint>(myVertex->x(), myVertex->y(), myVertex->z());
         }
       }
  
     } else {
       edm::Handle<SimVertexContainer> VertexHandle;
       evt.getByToken(simVertex_, VertexHandle);
  
       if (VertexHandle.isValid()) {
         if (!(*VertexHandle).empty())  //at least 1 vertex
         {
           assert((*VertexHandle)[0].vertexId() == 0);
           const SimVertex* myVertex = &(*VertexHandle)[0];
           vertex = std::make_unique<GlobalPoint>(
               myVertex->position().x(), myVertex->position().y(), myVertex->position().z());
         }
       }
     }
   }
  
   if (EBRecHits && ebTimeDigis) {
     // loop over uncalibrated rechits to make calibrated ones
     for (EBRecHitCollection::const_iterator it = EBRecHits->begin(); it != EBRecHits->end(); ++it) {
       EcalRecHit aHit((*it));
       EcalTimeDigiCollection::const_iterator timeDigi = ebTimeDigis->find((*it).id());
       if (timeDigi != ebTimeDigis->end()) {
         if (timeDigi->sampleOfInterest() >= 0) {
           float myTime = (*timeDigi)[timeDigi->sampleOfInterest()];
           //Vertex corrected ToF
           if (vertex) {
             aHit.setTime(myTime + deltaTimeOfFlight(*vertex, (*it).id(), ebTimeLayer_));
           } else
             //Uncorrected ToF
             aHit.setTime(myTime);
         }
       }
       // leave standard time if no timeDigi is associated (e.g. noise recHits)
       EBDetailedTimeRecHits->push_back(aHit);
     }
   }
  
   if (EERecHits && eeTimeDigis) {
     // loop over uncalibrated rechits to make calibrated ones
     for (EERecHitCollection::const_iterator it = EERecHits->begin(); it != EERecHits->end(); ++it) {
       EcalRecHit aHit(*it);
       EcalTimeDigiCollection::const_iterator timeDigi = eeTimeDigis->find((*it).id());
       if (timeDigi != eeTimeDigis->end()) {
         if (timeDigi->sampleOfInterest() >= 0) {
           float myTime = (*timeDigi)[timeDigi->sampleOfInterest()];
           //Vertex corrected ToF
           if (vertex) {
             aHit.setTime(myTime + deltaTimeOfFlight(*vertex, (*it).id(), eeTimeLayer_));
           } else
             //Uncorrected ToF
             aHit.setTime(myTime);
         }
       }
       EEDetailedTimeRecHits->push_back(aHit);
     }
   }
   // put the collection of recunstructed hits in the event
   LogInfo("EcalDetailedTimeRecHitInfo") << "total # EB rechits: " << EBDetailedTimeRecHits->size();
   LogInfo("EcalDetailedTimeRecHitInfo") << "total # EE rechits: " << EEDetailedTimeRecHits->size();
  
   evt.put(std::move(EBDetailedTimeRecHits), EBDetailedTimeRecHitCollection_);
   evt.put(std::move(EEDetailedTimeRecHits), EEDetailedTimeRecHitCollection_);
 }