#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

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

Private Member Functions
double	deltaTimeOfFlight (GlobalPoint &vertex, const DetId &detId, int layer) const

Private Attributes
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<>
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

produce ECAL detailed time Rechits

Author: Paolo Meridiani

produce ECAL rechits associating them with improved ecalTimeDigis

Author: Paolo Meridiani, INFN Roma

Definition at line 27 of file EcalDetailedTimeRecHitProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 45 of file EcalDetailedTimeRecHitProducer.cc.

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

                                                                                         :
   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") );
 
   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_);
 }

EcalDetailedTimeRecHitProducer::~EcalDetailedTimeRecHitProducer ( )

override

Definition at line 74 of file EcalDetailedTimeRecHitProducer.cc.

74 {

75 }

Member Function Documentation

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

private

Definition at line 233 of file EcalDetailedTimeRecHitProducer.cc.

References DEFINE_FWK_MODULE, CaloGeometry::getGeometry(), m_geometry, and PV3DBase< T, PVType, FrameType >::mag().

Referenced by produce().

 {
   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 ;
 }

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

override

Definition at line 78 of file EcalDetailedTimeRecHitProducer.cc.

References edm::SortedCollection< T, SORT >::begin(), correctForVertexZPosition_, deltaTimeOfFlight(), EBDetailedTimeRecHitCollection_, EBRecHitCollection_, egHLT::errCodes::EBRecHits, ebTimeDigiCollection_, ebTimeLayer_, EEDetailedTimeRecHitCollection_, EERecHitCollection_, egHLT::errCodes::EERecHits, eeTimeDigiCollection_, eeTimeLayer_, edm::SortedCollection< T, SORT >::end(), edm::SortedCollection< T, SORT >::find(), edm::EventSetup::get(), edm::Event::getByToken(), edm::HandleBase::isValid(), LogDebug, m_geometry, eostools::move(), CoreSimVertex::position(), edm::Handle< T >::product(), edm::ESHandle< T >::product(), edm::Event::put(), recoVertex_, EcalRecHit::setTime(), simVertex_, edm::SortedCollection< T, SORT >::size(), useMCTruthVertex_, reco::Vertex::x(), reco::Vertex::y(), and reco::Vertex::z().

 {
         using namespace edm;
         using namespace reco;
 
     edm::ESHandle<CaloGeometry>               hGeometry   ;
     es.get<CaloGeometryRecord>().get( hGeometry ) ;
     
     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.reset( new 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.reset( new 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_ );
 
 }