Inheritance diagram for AlignmentMonitorTemplate:

Public Member Functions
void	afterAlignment () override

	AlignmentMonitorTemplate (const edm::ParameterSet &cfg)

void	book () override
	Book or retrieve histograms; MUST be reimplemented. More...

void	event (const edm::Event &iEvent, const edm::EventSetup &iSetup, const ConstTrajTrackPairCollection &iTrajTracks) override
	Called for each event (by "run()"): may be reimplemented. More...

	~AlignmentMonitorTemplate () override

Public Member Functions inherited from AlignmentMonitorBase
	AlignmentMonitorBase (const edm::ParameterSet &cfg, std::string name)
	Constructor. More...

void	beginOfJob (AlignableTracker pTracker, AlignableMuon pMuon, AlignmentParameterStore *pStore)
	Called at beginning of job: don't reimplement. More...

void	duringLoop (const edm::Event &iEvent, const edm::EventSetup &iSetup, const ConstTrajTrackPairCollection &iTrajTracks)
	Called for each event: don't reimplement. More...

void	endOfJob ()
	Called at end of processing: don't implement. More...

void	endOfLoop ()
	Called at end of loop: don't reimplement. More...

void	startingNewLoop ()
	Called at beginning of loop: don't reimplement. More...

virtual	~AlignmentMonitorBase ()
	Destructor. More...

Private Attributes
TH1F *	m_hist

TH1F *	m_ihist

TH1F *	m_otherdir

TH1F *	m_otherdir2

std::map< Alignable , TH1F >	m_residuals

Additional Inherited Members
Public Types inherited from AlignmentMonitorBase
typedef std::pair< const Trajectory , const reco::Track >	ConstTrajTrackPair

typedef std::vector< ConstTrajTrackPair >	ConstTrajTrackPairCollection

Protected Member Functions inherited from AlignmentMonitorBase
TH1F *	book1D (std::string dir, std::string name, std::string title, int nchX, double lowX, double highX)

TH2F *	book2D (std::string dir, std::string name, std::string title, int nchX, double lowX, double highX, int nchY, double lowY, double highY)

TProfile *	bookProfile (std::string dir, std::string name, std::string title, int nchX, double lowX, double highX, int nchY=1, double lowY=0., double highY=0., const char *option="s")

TFileDirectory *	directory (std::string dir)

int	iteration ()

AlignableMuon *	pMuon ()

AlignableNavigator *	pNavigator ()

AlignmentParameterStore *	pStore ()

AlignableTracker *	pTracker ()

Protected Attributes inherited from AlignmentMonitorBase
const edm::InputTag	m_beamSpotTag

Detailed Description

Definition at line 28 of file AlignmentMonitorTemplate.cc.

Constructor & Destructor Documentation

◆ AlignmentMonitorTemplate()

AlignmentMonitorTemplate::AlignmentMonitorTemplate ( const edm::ParameterSet & cfg )

inline

Definition at line 30 of file AlignmentMonitorTemplate.cc.

30 : AlignmentMonitorBase(cfg, "AlignmentMonitorTemplate"){};

◆ ~AlignmentMonitorTemplate()

AlignmentMonitorTemplate::~AlignmentMonitorTemplate ( )

inlineoverride

Definition at line 31 of file AlignmentMonitorTemplate.cc.

31 {};

Member Function Documentation

◆ afterAlignment()

void AlignmentMonitorTemplate::afterAlignment ( )

overridevirtual

Called after updating AlignableTracker and AlignableMuon (by "endOfLoop()"): may be reimplemented

Reimplemented from AlignmentMonitorBase.

Definition at line 129 of file AlignmentMonitorTemplate.cc.

                                               {
   m_otherdir->Fill(
       iteration());  // this one will only get one fill per iteration, because it's called in afterAlignment()
 }

References AlignmentMonitorBase::iteration(), and m_otherdir.

◆ book()

void AlignmentMonitorTemplate::book ( )

overridevirtual

Book or retrieve histograms; MUST be reimplemented.

Implements AlignmentMonitorBase.

Definition at line 56 of file AlignmentMonitorTemplate.cc.

                                     {
   m_hist = book1D("/", "hist", "hist", 10, 0.5, 10.5);      // there's only one of these per job
   m_ihist = book1D("/iterN/", "ihist", "ihist", 10, 0, 1);  // there's a new one of these for each iteration
   // "/iterN/" is a special directory name, in which the "N" gets replaced by the current iteration number.
  
   m_otherdir = book1D("/otherdir/", "hist", "this is a histogram in another directory", 10, 0.5, 10.5);
   m_otherdir2 =
       book1D("/iterN/otherdir/", "hist", "here's one in another directory inside the iterN directories", 10, 0.5, 10.5);
  
   // This is a procedure that makes one histogram for each selected alignable, and puts them in the iterN directory.
   // This is not a constant-time lookup.  If you need something faster, see AlignmentMonitorMuonHIP, which has a
   // dynamically-allocated array of TH1F*s.
   const auto& alignables = pStore()->alignables();
   for (const auto& it : alignables) {
     char name[256], title[256];
     snprintf(name, sizeof(name), "xresid%d", it->geomDetId().rawId());
     snprintf(title, sizeof(title), "x track-hit for DetId %d", it->geomDetId().rawId());
  
     m_residuals[it] = book1D("/iterN/", name, title, 100, -5., 5.);
   }
  
   // Important: you create TObject pointers with the "new" operator, but YOU don't delete them.  They're deleted by the
   // base class, which knows when they are no longer needed (based on whether they are in the /iterN/ directory or not).
  
   // For more detail, see the twiki page:
   // https://twiki.cern.ch/twiki/bin/view/CMS/SWGuideAlignmentMonitors    for creating a plugin like this one
   // https://twiki.cern.ch/twiki/bin/view/CMS/SWGuideAlignmentAlgorithms#Monitoring    for configuring it
 }

References AlignmentParameterStore::alignables(), AlignmentMonitorBase::book1D(), m_hist, m_ihist, m_otherdir, m_otherdir2, m_residuals, Skims_PA_cff::name, AlignmentMonitorBase::pStore(), and overlapproblemtsosanalyzer_cfi::title.

◆ event()

void AlignmentMonitorTemplate::event	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		const ConstTrajTrackPairCollection &	iTrajTracks
	)

overridevirtual

Called for each event (by "run()"): may be reimplemented.

Reimplemented from AlignmentMonitorBase.

Definition at line 85 of file AlignmentMonitorTemplate.cc.

                                                                                  {
   m_hist->Fill(iteration());  // get the number of events per iteration
   m_ihist->Fill(0.5);         // get the number of events in this iteration in the central bin
  
   TrajectoryStateCombiner tsoscomb;
  
   // This is a procedure that loops over tracks/hits, calculates residuals, and fills the appropriate histogram.
   for (ConstTrajTrackPairCollection::const_iterator it = tracks.begin(); it != tracks.end(); ++it) {
     const Trajectory* traj = it->first;
     //      const reco::Track* track = it->second;
     // If your tracks are refit using the producer in RecoTracker, you'll get updated reco::Track objects with
     // each iteration, and it makes sense to make plots using these.
     // If your tracks are refit using TrackingTools/TrackRefitter, only the Trajectories will be updated.
     // We're working on that.  I'll try to remember to change this comment when the update is ready.
  
     std::vector<TrajectoryMeasurement> measurements = traj->measurements();
     for (std::vector<TrajectoryMeasurement>::const_iterator im = measurements.begin(); im != measurements.end(); ++im) {
       const TrajectoryMeasurement meas = *im;
       const TransientTrackingRecHit* hit = &(*meas.recHit());
       const DetId id = hit->geographicalId();
  
       if (hit->isValid() && pNavigator()->detAndSubdetInMap(id)) {
         // Combine the forward-propagated state with the backward-propagated state to get a minimally-biased residual.
         // This is the same procedure that is used to calculate residuals in the HIP algorithm
         TrajectoryStateOnSurface tsosc = tsoscomb.combine(meas.forwardPredictedState(), meas.backwardPredictedState());
  
         // Search for our histogram using the Alignable* -> TH1F* map
         // The "alignable = alignable->mother()" part ascends the alignable tree, because hits are on the lowest-level
         // while our histograms may be associated with higher-level Alignables.
         Alignable* alignable = pNavigator()->alignableFromDetId(id);
         std::map<Alignable*, TH1F*>::const_iterator search = m_residuals.find(alignable);
         while (search == m_residuals.end() && (alignable = alignable->mother()))
           search = m_residuals.find(alignable);
  
         if (search != m_residuals.end()) {
           search->second->Fill(tsosc.localPosition().x() - hit->localPosition().x());
         }
       }  // end if hit is valid
     }    // end loop over hits
   }      // end loop over tracks/trajectories
 }