#include <Dummy/AlignmentMonitorAsAnalyzer/src/AlignmentMonitorAsAnalyzer.cc>

Inheritance diagram for AlignmentMonitorAsAnalyzer:

Public Types
typedef std::pair< const Trajectory , const reco::Track >	ConstTrajTrackPair

typedef std::vector< ConstTrajTrackPair >	ConstTrajTrackPairCollection

Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

	~AlignmentMonitorAsAnalyzer () override=default

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

	EDAnalyzer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

	~EDAnalyzer () override

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 &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

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 &	operator= (EDConsumerBase &&)=default

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

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

void	beginJob () override

void	endJob () override

Private Attributes
std::unique_ptr< AlignableMuon >	m_alignableMuon

std::unique_ptr< AlignableTracker >	m_alignableTracker

std::unique_ptr< AlignmentParameterStore >	m_alignmentParameterStore

edm::ParameterSet	m_aliParamStoreCfg

bool	m_firstEvent

std::vector< std::unique_ptr< AlignmentMonitorBase > >	m_monitors

edm::InputTag	m_tjTag

Additional Inherited Members
Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

Detailed Description

Description: <one line="" class="" summary>="">

Implementation: <Notes on="" implementation>="">

Definition at line 65 of file AlignmentMonitorAsAnalyzer.cc.

Member Typedef Documentation

◆ ConstTrajTrackPair

typedef std::pair<const Trajectory*, const reco::Track*> AlignmentMonitorAsAnalyzer::ConstTrajTrackPair

Definition at line 70 of file AlignmentMonitorAsAnalyzer.cc.

◆ ConstTrajTrackPairCollection

typedef std::vector<ConstTrajTrackPair> AlignmentMonitorAsAnalyzer::ConstTrajTrackPairCollection

Definition at line 71 of file AlignmentMonitorAsAnalyzer.cc.

Constructor & Destructor Documentation

◆ AlignmentMonitorAsAnalyzer()

AlignmentMonitorAsAnalyzer::AlignmentMonitorAsAnalyzer ( const edm::ParameterSet & iConfig )

explicit

Definition at line 102 of file AlignmentMonitorAsAnalyzer.cc.

     : m_tjTag(iConfig.getParameter<edm::InputTag>("tjTkAssociationMapTag")),
       m_aliParamStoreCfg(iConfig.getParameter<edm::ParameterSet>("ParameterStore")) {
   std::vector<std::string> monitors = iConfig.getUntrackedParameter<std::vector<std::string>>("monitors");
  
   for (auto const& mon : monitors) {
     m_monitors.emplace_back(
         AlignmentMonitorPluginFactory::get()->create(mon, iConfig.getUntrackedParameter<edm::ParameterSet>(mon)));
   }
 }

References beamerCreator::create(), get, edm::ParameterSet::getUntrackedParameter(), m_monitors, LaserDQM_cfi::mon, and gather_cfg::monitors.

◆ ~AlignmentMonitorAsAnalyzer()

AlignmentMonitorAsAnalyzer::~AlignmentMonitorAsAnalyzer ( )

overridedefault

Member Function Documentation

◆ analyze()

void AlignmentMonitorAsAnalyzer::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivatevirtual

Implements edm::EDAnalyzer.

Definition at line 118 of file AlignmentMonitorAsAnalyzer.cc.

                                                                                             {
   //Retrieve tracker topology from geometry
   edm::ESHandle<TrackerTopology> tTopoHandle;
   iSetup.get<TrackerTopologyRcd>().get(tTopoHandle);
   const TrackerTopology* const tTopo = tTopoHandle.product();
  
   if (m_firstEvent) {
     GeometryAligner aligner;
  
     edm::ESTransientHandle<DDCompactView> cpv;
     iSetup.get<IdealGeometryRecord>().get(cpv);
  
     edm::ESHandle<GeometricDet> theGeometricDet;
     iSetup.get<IdealGeometryRecord>().get(theGeometricDet);
     edm::ESHandle<PTrackerParameters> ptp;
     iSetup.get<PTrackerParametersRcd>().get(ptp);
     TrackerGeomBuilderFromGeometricDet trackerBuilder;
     std::shared_ptr<TrackerGeometry> theTracker(trackerBuilder.build(&(*theGeometricDet), *ptp, tTopo));
  
     edm::ESHandle<MuonGeometryConstants> mdc;
     iSetup.get<IdealGeometryRecord>().get(mdc);
     DTGeometryBuilderFromDDD DTGeometryBuilder;
     CSCGeometryBuilderFromDDD CSCGeometryBuilder;
     auto theMuonDT = std::make_shared<DTGeometry>();
     DTGeometryBuilder.build(*theMuonDT, &(*cpv), *mdc);
     auto theMuonCSC = std::make_shared<CSCGeometry>();
     CSCGeometryBuilder.build(*theMuonCSC, &(*cpv), *mdc);
  
     edm::ESHandle<Alignments> globalPositionRcd;
     iSetup.get<GlobalPositionRcd>().get(globalPositionRcd);
  
     edm::ESHandle<Alignments> alignments;
     iSetup.get<TrackerAlignmentRcd>().get(alignments);
     edm::ESHandle<AlignmentErrorsExtended> alignmentErrors;
     iSetup.get<TrackerAlignmentErrorExtendedRcd>().get(alignmentErrors);
     aligner.applyAlignments<TrackerGeometry>(&(*theTracker),
                                              &(*alignments),
                                              &(*alignmentErrors),
                                              align::DetectorGlobalPosition(*globalPositionRcd, DetId(DetId::Tracker)));
  
     edm::ESHandle<Alignments> dtAlignments;
     iSetup.get<DTAlignmentRcd>().get(dtAlignments);
     edm::ESHandle<AlignmentErrorsExtended> dtAlignmentErrorsExtended;
     iSetup.get<DTAlignmentErrorExtendedRcd>().get(dtAlignmentErrorsExtended);
     aligner.applyAlignments<DTGeometry>(&(*theMuonDT),
                                         &(*dtAlignments),
                                         &(*dtAlignmentErrorsExtended),
                                         align::DetectorGlobalPosition(*globalPositionRcd, DetId(DetId::Muon)));
  
     edm::ESHandle<Alignments> cscAlignments;
     iSetup.get<CSCAlignmentRcd>().get(cscAlignments);
     edm::ESHandle<AlignmentErrorsExtended> cscAlignmentErrorsExtended;
     iSetup.get<CSCAlignmentErrorExtendedRcd>().get(cscAlignmentErrorsExtended);
     aligner.applyAlignments<CSCGeometry>(&(*theMuonCSC),
                                          &(*cscAlignments),
                                          &(*cscAlignmentErrorsExtended),
                                          align::DetectorGlobalPosition(*globalPositionRcd, DetId(DetId::Muon)));
  
     // within an analyzer, modules can't expect to see any selected alignables!
     align::Alignables empty_alignables;
  
     m_alignableTracker = std::make_unique<AlignableTracker>(&(*theTracker), tTopo);
     m_alignableMuon = std::make_unique<AlignableMuon>(&(*theMuonDT), &(*theMuonCSC));
     m_alignmentParameterStore = std::make_unique<AlignmentParameterStore>(empty_alignables, m_aliParamStoreCfg);
  
     for (auto const& monitor : m_monitors) {
       monitor->beginOfJob(m_alignableTracker.get(), m_alignableMuon.get(), m_alignmentParameterStore.get());
     }
     for (auto const& monitor : m_monitors) {
       monitor->startingNewLoop();
     }
  
     m_firstEvent = false;
   }
  
   // Retrieve trajectories and tracks from the event
   edm::Handle<TrajTrackAssociationCollection> trajTracksMap;
   iEvent.getByLabel(m_tjTag, trajTracksMap);
  
   // Form pairs of trajectories and tracks
   ConstTrajTrackPairCollection trajTracks;
   for (const auto& iPair : *trajTracksMap) {
     trajTracks.push_back(ConstTrajTrackPair(&(*iPair.key), &(*iPair.val)));
   }
  
   // Run the monitors
   for (const auto& monitor : m_monitors) {
     monitor->duringLoop(iEvent, iSetup, trajTracks);
   }
 }

References GeometryAligner::applyAlignments(), TrackerGeomBuilderFromGeometricDet::build(), CSCGeometryBuilder::build(), align::DetectorGlobalPosition(), edm::EventSetup::get(), get, iEvent, m_alignableMuon, m_alignableTracker, m_alignmentParameterStore, m_aliParamStoreCfg, m_firstEvent, m_monitors, m_tjTag, beam_dqm_sourceclient-live_cfg::monitor, DetId::Muon, edm::ESHandle< T >::product(), and DetId::Tracker.

◆ beginJob()

void AlignmentMonitorAsAnalyzer::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 210 of file AlignmentMonitorAsAnalyzer.cc.

210 { m_firstEvent = true; }

References m_firstEvent.

◆ endJob()

void AlignmentMonitorAsAnalyzer::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 213 of file AlignmentMonitorAsAnalyzer.cc.

                                         {
   for (auto const& monitor : m_monitors) {
     monitor->endOfLoop();
   }
   for (auto const& monitor : m_monitors) {
     monitor->endOfJob();
   }
 }