#include <Histograms.h>

Public Types
typedef dqm::legacy::DQMStore	DQMStore

typedef dqm::legacy::MonitorElement	MonitorElement

Public Member Functions
void	fill (float simDirectionAlpha, float recDirectionAlpha, float simDirectionBeta, float recDirectionBeta, float simX, float recX, float simY, float recY, float simEta, float simPhi, float recYRZ, float simYRZ, float recBetaRZ, float simBetaRZ, float sigmaAlpha, float sigmaBeta, float sigmaX, float sigmaY, float sigmaBetaRZ, float sigmaYRZ, int nHitsPhi, int nHitsTheta, float t0Phi, float t0Theta)

	HRes4DHit (const std::string &name, DQMStore::IBooker &booker, bool doall=true, bool local=true)

Private Attributes
bool	doall_

dqm::reco::MonitorElement *	hHitMult

dqm::reco::MonitorElement *	hPullAlpha

dqm::reco::MonitorElement *	hPullAlphaVsEta

dqm::reco::MonitorElement *	hPullAlphaVsPhi

dqm::reco::MonitorElement *	hPullBeta

dqm::reco::MonitorElement *	hPullBetaRZ

dqm::reco::MonitorElement *	hPullBetaVsEta

dqm::reco::MonitorElement *	hPullBetaVsEtaRZ

dqm::reco::MonitorElement *	hPullBetaVsPhi

dqm::reco::MonitorElement *	hPullBetaVsPhiRZ

dqm::reco::MonitorElement *	hPullX

dqm::reco::MonitorElement *	hPullXVsEta

dqm::reco::MonitorElement *	hPullXVsPhi

dqm::reco::MonitorElement *	hPullY

dqm::reco::MonitorElement *	hPullYRZ

dqm::reco::MonitorElement *	hPullYVsEta

dqm::reco::MonitorElement *	hPullYVsEtaRZ

dqm::reco::MonitorElement *	hPullYVsPhi

dqm::reco::MonitorElement *	hPullYVsPhiRZ

dqm::reco::MonitorElement *	hRecAlpha

dqm::reco::MonitorElement *	hRecBeta

dqm::reco::MonitorElement *	hRecBetaRZ

dqm::reco::MonitorElement *	hRecVsSimAlpha

dqm::reco::MonitorElement *	hRecVsSimBeta

dqm::reco::MonitorElement *	hRecVsSimBetaRZ

dqm::reco::MonitorElement *	hResAlpha

dqm::reco::MonitorElement *	hResAlphaVsEta

dqm::reco::MonitorElement *	hResAlphaVsPhi

dqm::reco::MonitorElement *	hResAlphaVsResBeta

dqm::reco::MonitorElement *	hResAlphaVsResX

dqm::reco::MonitorElement *	hResAlphaVsResY

dqm::reco::MonitorElement *	hResBeta

dqm::reco::MonitorElement *	hResBetaRZ

dqm::reco::MonitorElement *	hResBetaVsEta

dqm::reco::MonitorElement *	hResBetaVsEtaRZ

dqm::reco::MonitorElement *	hResBetaVsPhi

dqm::reco::MonitorElement *	hResBetaVsPhiRZ

dqm::reco::MonitorElement *	hResX

dqm::reco::MonitorElement *	hResXVsEta

dqm::reco::MonitorElement *	hResXVsPhi

dqm::reco::MonitorElement *	hResXVsResY

dqm::reco::MonitorElement *	hResY

dqm::reco::MonitorElement *	hResYRZ

dqm::reco::MonitorElement *	hResYVsEta

dqm::reco::MonitorElement *	hResYVsEtaRZ

dqm::reco::MonitorElement *	hResYVsPhi

dqm::reco::MonitorElement *	hResYVsPhiRZ

dqm::reco::MonitorElement *	hSimAlpha

dqm::reco::MonitorElement *	hSimBeta

dqm::reco::MonitorElement *	hSimBetaRZ

dqm::reco::MonitorElement *	ht0

bool	local_

std::string	name_

Detailed Description

Definition at line 421 of file Histograms.h.

Member Typedef Documentation

typedef dqm::legacy::DQMStore HRes4DHit::DQMStore

Definition at line 423 of file Histograms.h.

typedef dqm::legacy::MonitorElement HRes4DHit::MonitorElement

Definition at line 424 of file Histograms.h.

Constructor & Destructor Documentation

HRes4DHit::HRes4DHit	(	const std::string &	name,
		DQMStore::IBooker &	booker,
		bool	doall = `true`,
		bool	local = `true`
	)

inline

Definition at line 426 of file Histograms.h.

References dqm::dqmstoreimpl::DQMStore::IBooker::book1D(), dqm::dqmstoreimpl::DQMStore::IBooker::book2D(), DTRecHitClients_cfi::doall, HRes1DHit::doall_, Skims_PA_cff::name, dqm::dqmstoreimpl::DQMStore::IBooker::setCurrentFolder(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                   : local_(local) {
     std::string pre = "4D_";
     pre += name;
     doall_ = doall;
 
     booker.setCurrentFolder("DT/4DSegments/Res/");
     if (doall) {
       hRecAlpha =
           booker.book1D(pre + "_hRecAlpha", "4D RecHit alpha (RPhi) distribution;#alpha^{x} (rad)", 100, -1.5, 1.5);
       hRecBeta = booker.book1D(pre + "_hRecBeta", "4D RecHit beta distribution:#alpha^{y} (rad)", 100, -1.5, 1.5);
 
       hSimAlpha = booker.book1D(
           pre + "_hSimAlpha", "4D segment from SimHit alpha (RPhi) distribution;i#alpha^{x} (rad)", 100, -1.5, 1.5);
       hSimBeta =
           booker.book1D(pre + "_hSimBeta", "4D segment from SimHit beta distribution;#alpha^{y} (rad)", 100, -1.5, 1.5);
       hRecVsSimAlpha = booker.book2D(pre + "_hRecVsSimAlpha",
                                      "4D segment rec alpha {v}s sim alpha (RPhi);#alpha^{x} (rad)",
                                      100,
                                      -1.5,
                                      1.5,
                                      100,
                                      -1.5,
                                      1.5);
       hRecVsSimBeta = booker.book2D(pre + "_hRecVsSimBeta",
                                     "4D segment rec beta vs sim beta (RZ);#alpha^{y} (rad)",
                                     100,
                                     -1.5,
                                     1.5,
                                     100,
                                     -1.5,
                                     1.5);
 
       hResAlphaVsEta = booker.book2D(pre + "_hResAlphaVsEta",
                                      "4D RecHit residual on #alpha_x direction vs "
                                      "eta;#eta;#alpha^{x}_{rec}-#alpha^{x}_{sim} (rad)",
                                      100,
                                      -2.5,
                                      2.5,
                                      100,
                                      -0.025,
                                      0.025);
       hResAlphaVsPhi = booker.book2D(pre + "_hResAlphaVsPhi",
                                      "4D RecHit residual on #alpha_x direction vs phi (rad);#phi "
                                      "(rad);#alpha^{x}_{rec}-#alpha^{x}_{sim} (rad)",
                                      100,
                                      -3.2,
                                      3.2,
                                      100,
                                      -0.025,
                                      0.025);
       hResBetaVsEta = booker.book2D(pre + "_hResBetaVsEta",
                                     "4D RecHit residual on beta direction vs "
                                     "eta;#eta;#alpha^{y}_{rec}-#alpha^{y}_{sim} (rad)",
                                     100,
                                     -2.5,
                                     2.5,
                                     200,
                                     -0.2,
                                     0.2);
       hResBetaVsPhi = booker.book2D(pre + "_hResBetaVsPhi",
                                     "4D RecHit residual on beta direction vs phi;#phi "
                                     "(rad);#alpha^{y}_{rec}-#alpha^{y}_{sim} (rad)",
                                     100,
                                     -3.2,
                                     3.2,
                                     200,
                                     -0.2,
                                     0.2);
 
       hResXVsEta = booker.book2D(pre + "_hResXVsEta",
                                  "4D RecHit residual on position (x) in "
                                  "chamber vs eta;#eta;x_{rec}-x_{sim} (cm)",
                                  100,
                                  -2.5,
                                  2.5,
                                  150,
                                  -0.3,
                                  0.3);
       hResXVsPhi = booker.book2D(pre + "_hResXVsPhi",
                                  "4D RecHit residual on position (x) in chamber vs "
                                  "phi;#phi (rad);x_{rec}-x_{sim} (cm)",
                                  100,
                                  -3.2,
                                  3.2,
                                  150,
                                  -0.3,
                                  0.3);
 
       hResYVsEta = booker.book2D(pre + "_hResYVsEta",
                                  "4D RecHit residual on position (y) in "
                                  "chamber vs eta;#eta;y_{rec}-y_{sim} (cm)",
                                  100,
                                  -2.5,
                                  2.5,
                                  150,
                                  -0.6,
                                  0.6);
       hResYVsPhi = booker.book2D(pre + "_hResYVsPhi",
                                  "4D RecHit residual on position (y) in chamber vs "
                                  "phi;#phi (rad);y_{rec}-y_{sim} (cm)",
                                  100,
                                  -3.2,
                                  3.2,
                                  150,
                                  -0.6,
                                  0.6);
 
       hResAlphaVsResBeta = booker.book2D(pre + "_hResAlphaVsResBeta",
                                          "4D RecHit residual on alpha vs residual on beta",
                                          200,
                                          -0.3,
                                          0.3,
                                          500,
                                          -0.15,
                                          0.15);
       hResXVsResY = booker.book2D(
           pre + "_hResXVsResY", "4D RecHit residual on X vs residual on Y", 150, -0.6, 0.6, 50, -0.3, 0.3);
       hResAlphaVsResX = booker.book2D(
           pre + "_hResAlphaVsResX", "4D RecHit residual on alpha vs residual on x", 150, -0.3, 0.3, 500, -0.15, 0.15);
 
       hResAlphaVsResY = booker.book2D(
           pre + "_hResAlphaVsResY", "4D RecHit residual on alpha vs residual on y", 150, -0.6, 0.6, 500, -0.15, 0.15);
 
       hRecBetaRZ = booker.book1D(pre + "_hRecBetaRZ", "4D RecHit beta distribution:#alpha^{y} (rad)", 100, -1.5, 1.5);
 
       hSimBetaRZ = booker.book1D(
           pre + "_hSimBetaRZ", "4D segment from SimHit beta distribution in RZ SL;#alpha^{y} (rad)", 100, -1.5, 1.5);
       hRecVsSimBetaRZ = booker.book2D(pre + "_hRecVsSimBetaRZ",
                                       "4D segment rec beta vs sim beta (RZ) in RZ SL;#alpha^{y} (rad)",
                                       100,
                                       -1.5,
                                       1.5,
                                       100,
                                       -1.5,
                                       1.5);
 
       hResBetaVsEtaRZ = booker.book2D(pre + "_hResBetaVsEtaRZ",
                                       "4D RecHit residual on beta direction vs eta;#eta in "
                                       "RZ SL;#alpha^{y}_{rec}-#alpha^{y}_{sim} (rad)",
                                       100,
                                       -2.5,
                                       2.5,
                                       200,
                                       -0.2,
                                       0.2);
       hResBetaVsPhiRZ = booker.book2D(pre + "_hResBetaVsPhiRZ",
                                       "4D RecHit residual on beta direction vs phi in RZ "
                                       "SL;#phi (rad);#alpha^{y}_{rec}-#alpha^{y}_{sim} (rad)",
                                       100,
                                       -3.2,
                                       3.2,
                                       200,
                                       -0.2,
                                       0.2);
       hResYVsEtaRZ = booker.book2D(pre + "_hResYVsEtaRZ",
                                    "4D RecHit residual on position (y) in chamber vs eta "
                                    "in RZ SL;#eta;y_{rec}-y_{sim} (cm)",
                                    100,
                                    -2.5,
                                    2.5,
                                    150,
                                    -0.6,
                                    0.6);
       hResYVsPhiRZ = booker.book2D(pre + "_hResYVsPhiRZ",
                                    "4D RecHit residual on position (y) in chamber vs phi "
                                    "in RZ SL;#phi (rad);y_{rec}-y_{sim} (cm)",
                                    100,
                                    -3.2,
                                    3.2,
                                    150,
                                    -0.6,
                                    0.6);
 
       booker.setCurrentFolder("DT/4DSegments/Pull/");
       hPullAlphaVsEta = booker.book2D(pre + "_hPullAlphaVsEta",
                                       "4D RecHit pull on #alpha_x direction vs "
                                       "eta;#eta;(#alpha^{x}_{rec}-#alpha^{x}_{sim})/#sigma",
                                       100,
                                       -2.5,
                                       2.5,
                                       100,
                                       -5,
                                       5);
       hPullAlphaVsPhi = booker.book2D(pre + "_hPullAlphaVsPhi",
                                       "4D RecHit pull on #alpha_x direction vs phi (rad);#phi "
                                       "(rad);(#alpha^{x}_{rec}-#alpha^{x}_{sim})/#sigma",
                                       100,
                                       -3.2,
                                       3.2,
                                       100,
                                       -5,
                                       5);
       hPullBetaVsEta = booker.book2D(pre + "_hPullBetaVsEta",
                                      "4D RecHit pull on beta direction vs "
                                      "eta;#eta;(#alpha^{y}_{rec}-#alpha^{y}_{sim})/#sigma",
                                      100,
                                      -2.5,
                                      2.5,
                                      200,
                                      -5,
                                      5);
       hPullBetaVsPhi = booker.book2D(pre + "_hPullBetaVsPhi",
                                      "4D RecHit pull on beta direction vs phi;#phi "
                                      "(rad);(#alpha^{y}_{rec}-#alpha^{y}_{sim})/#sigma",
                                      100,
                                      -3.2,
                                      3.2,
                                      200,
                                      -5,
                                      5);
       hPullXVsEta = booker.book2D(pre + "_hPullXVsEta",
                                   "4D RecHit pull on position (x) in chamber "
                                   "vs eta;#eta;(x_{rec}-x_{sim})#sigma",
                                   100,
                                   -2.5,
                                   2.5,
                                   150,
                                   -5,
                                   5);
       hPullXVsPhi = booker.book2D(pre + "_hPullXVsPhi",
                                   "4D RecHit pull on position (x) in chamber "
                                   "vs phi;#phi (rad);(x_{rec}-x_{sim})/#sigma",
                                   100,
                                   -3.2,
                                   3.2,
                                   150,
                                   -5,
                                   5);
       hPullYVsEta = booker.book2D(pre + "_hPullYVsEta",
                                   "4D RecHit pull on position (y) in chamber "
                                   "vs eta;#eta;(y_{rec}-y_{sim})/#sigma",
                                   100,
                                   -2.5,
                                   2.5,
                                   150,
                                   -5,
                                   5);
       hPullYVsPhi = booker.book2D(pre + "_hPullYVsPhi",
                                   "4D RecHit pull on position (y) in chamber "
                                   "vs phi;#phi (rad);(y_{rec}-y_{sim})/#sigma",
                                   100,
                                   -3.2,
                                   3.2,
                                   150,
                                   -5,
                                   5);
       hPullBetaVsEtaRZ = booker.book2D(pre + "_hPullBetaVsEtaRZ",
                                        "4D RecHit pull on beta direction vs eta;#eta in RZ "
                                        "SL;(#alpha^{y}_{rec}-#alpha^{y}_{sim})/#sigma",
                                        100,
                                        -2.5,
                                        2.5,
                                        200,
                                        -5,
                                        5);
       hPullBetaVsPhiRZ = booker.book2D(pre + "_hPullBetaVsPhiRZ",
                                        "4D RecHit pull on beta direction vs phi in RZ SL;#phi "
                                        "(rad);(#alpha^{y}_{rec}-#alpha^{y}_{sim})/#sigma",
                                        100,
                                        -3.2,
                                        3.2,
                                        200,
                                        -5,
                                        5);
       hPullYVsEtaRZ = booker.book2D(pre + "_hPullYVsEtaRZ",
                                     "4D RecHit pull on position (y) in chamber vs eta in "
                                     "RZ SL;#eta;(y_{rec}-y_{sim})/#sigma",
                                     100,
                                     -2.5,
                                     2.5,
                                     150,
                                     -5,
                                     5);
       hPullYVsPhiRZ = booker.book2D(pre + "_hPullYVsPhiRZ",
                                     "4D RecHit pull on position (y) in chamber vs phi in "
                                     "RZ SL;#phi (rad);(y_{rec}-y_{sim})/#sigma",
                                     100,
                                     -3.2,
                                     3.2,
                                     150,
                                     -5,
                                     5);
     }
     booker.setCurrentFolder("DT/4DSegments/Res/");
     hResAlpha = booker.book1D(pre + "_hResAlpha",
                               "4D RecHit residual on #alpha_x "
                               "direction;#alpha^{x}_{rec}-#alpha^{x}_{sim} (rad)",
                               200,
                               -0.015,
                               0.015);
 
     hResBeta = booker.book1D(pre + "_hResBeta",
                              "4D RecHit residual on beta "
                              "direction;#alpha^{y}_{rec}-#alpha^{y}_{sim} (rad)",
                              200,
                              -0.1,
                              0.1);
     hResX = booker.book1D(
         pre + "_hResX", "4D RecHit residual on position (x) in chamber;x_{rec}-x_{sim} (cm)", 150, -0.15, 0.15);
     hResY = booker.book1D(
         pre + "_hResY", "4D RecHit residual on position (y) in chamber;y_{rec}-y_{sim} (cm)", 150, -0.6, 0.6);
 
     // histo in rz SL reference frame.
     hResBetaRZ = booker.book1D(pre + "_hResBetaRZ",
                                "4D RecHit residual on beta direction in RZ "
                                "SL;#alpha^{y}_{rec}-#alpha^{y}_{sim} (rad)",
                                200,
                                -0.1,
                                0.1);
 
     hResYRZ = booker.book1D(pre + "_hResYRZ",
                             "4D RecHit residual on position (y) in chamber in "
                             "RZ SL;y_{rec}-y_{sim} (cm)",
                             150,
                             -0.15,
                             0.15);
 
     // Pulls
     booker.setCurrentFolder("DT/4DSegments/Pull/");
 
     hPullAlpha = booker.book1D(pre + "_hPullAlpha",
                                "4D RecHit pull on #alpha_x "
                                "direction;(#alpha^{x}_{rec}-#alpha^{x}_{sim})/#sigma",
                                200,
                                -5,
                                5);
     hPullBeta = booker.book1D(pre + "_hPullBeta",
                               "4D RecHit pull on beta "
                               "direction;(#alpha^{y}_{rec}-#alpha^{y}_{sim})/#sigma",
                               200,
                               -5,
                               5);
 
     hPullX =
         booker.book1D(pre + "_hPullX", "4D RecHit pull on position (x) in chamber;(x_{rec}-x_{sim})#sigma", 150, -5, 5);
 
     hPullY = booker.book1D(
         pre + "_hPullY", "4D RecHit pull on position (y) in chamber;(y_{rec}-y_{sim})/#sigma", 150, -5, 5);
 
     hPullBetaRZ = booker.book1D(pre + "_hPullBetaRZ",
                                 "4D RecHit pull on beta direction in RZ "
                                 "SL;(#alpha^{y}_{rec}-#alpha^{y}_{sim})/#sigma",
                                 200,
                                 -5,
                                 5);
 
     hPullYRZ = booker.book1D(pre + "_hPullYRZ",
                              "4D RecHit pull on position (y) in chamber in RZ "
                              "SL;(y_{rec}-y_{sim})/#sigma",
                              150,
                              -5,
                              5);
 
     // NHits, t0
     if (local_) {
       booker.setCurrentFolder("DT/4DSegments/");
       hHitMult = booker.book2D(pre + "_hNHits", "NHits", 12, 0, 12, 6, 0, 6);
       ht0 = booker.book2D(pre + "_ht0", "t0", 200, -25, 25, 200, -25, 25);
     }
   }

Member Function Documentation

void HRes4DHit::fill	(	float	simDirectionAlpha,
		float	recDirectionAlpha,
		float	simDirectionBeta,
		float	recDirectionBeta,
		float	simX,
		float	recX,
		float	simY,
		float	recY,
		float	simEta,
		float	simPhi,
		float	recYRZ,
		float	simYRZ,
		float	recBetaRZ,
		float	simBetaRZ,
		float	sigmaAlpha,
		float	sigmaBeta,
		float	sigmaX,
		float	sigmaY,
		float	sigmaBetaRZ,
		float	sigmaYRZ,
		int	nHitsPhi,
		int	nHitsTheta,
		float	t0Phi,
		float	t0Theta
	)

inline

Definition at line 787 of file Histograms.h.

References HRes1DHit::doall_.

Referenced by DTSegment4DQuality::dqmAnalyze().

                            {
     float resAlpha = recDirectionAlpha - simDirectionAlpha;
     hResAlpha->Fill(resAlpha);
     hPullAlpha->Fill(resAlpha / sigmaAlpha);
     float resBeta = recDirectionBeta - simDirectionBeta;
     hResBeta->Fill(resBeta);
     hPullBeta->Fill(resBeta / sigmaBeta);
     float resX = recX - simX;
     hResX->Fill(resX);
     hPullX->Fill(resX / sigmaX);
     float resY = recY - simY;
     hResY->Fill(resY);
     hPullY->Fill(resY / sigmaY);
 
     float resBetaRZ = recBetaRZ - simBetaRZ;
     hResBetaRZ->Fill(resBetaRZ);
     hPullBetaRZ->Fill(resBetaRZ / sigmaBetaRZ);
     float resYRZ = recYRZ - simYRZ;
     hResYRZ->Fill(resYRZ);
     hPullYRZ->Fill(resYRZ / sigmaYRZ);
     if (doall_) {
       hRecAlpha->Fill(recDirectionAlpha);
       hRecBeta->Fill(recDirectionBeta);
       hSimAlpha->Fill(simDirectionAlpha);
       hSimBeta->Fill(simDirectionBeta);
       hRecVsSimAlpha->Fill(simDirectionAlpha, recDirectionAlpha);
       hRecVsSimBeta->Fill(simDirectionBeta, recDirectionBeta);
       hResAlphaVsEta->Fill(simEta, resAlpha);
       hResAlphaVsPhi->Fill(simPhi, resAlpha);
       hPullAlphaVsEta->Fill(simEta, resAlpha / sigmaAlpha);
       hPullAlphaVsPhi->Fill(simPhi, resAlpha / sigmaAlpha);
       hResBetaVsEta->Fill(simEta, resBeta);
       hResBetaVsPhi->Fill(simPhi, resBeta);
       hPullBetaVsEta->Fill(simEta, resBeta / sigmaBeta);
       hPullBetaVsPhi->Fill(simPhi, resBeta / sigmaBeta);
       hResXVsEta->Fill(simEta, resX);
       hResXVsPhi->Fill(simPhi, resX);
       hPullXVsEta->Fill(simEta, resX / sigmaX);
       hPullXVsPhi->Fill(simPhi, resX / sigmaX);
       hResYVsEta->Fill(simEta, resY);
       hResYVsPhi->Fill(simPhi, resY);
       hPullYVsEta->Fill(simEta, resY / sigmaY);
       hPullYVsPhi->Fill(simPhi, resY / sigmaY);
       hResAlphaVsResBeta->Fill(resBeta, resAlpha);
       hResXVsResY->Fill(resY, resX);
       hResAlphaVsResX->Fill(resX, resAlpha);
       hResAlphaVsResY->Fill(resY, resAlpha);
 
       // RZ SuperLayer
       hRecBetaRZ->Fill(recBetaRZ);
       hSimBetaRZ->Fill(simBetaRZ);
       hRecVsSimBetaRZ->Fill(simBetaRZ, recBetaRZ);
       hResBetaVsEtaRZ->Fill(simEta, resBetaRZ);
       hResBetaVsPhiRZ->Fill(simPhi, resBetaRZ);
       hPullBetaVsEtaRZ->Fill(simEta, resBetaRZ / sigmaBetaRZ);
       hPullBetaVsPhiRZ->Fill(simPhi, resBetaRZ / sigmaBetaRZ);
       hResYVsEtaRZ->Fill(simEta, resYRZ);
       hResYVsPhiRZ->Fill(simPhi, resYRZ);
       hPullYVsEtaRZ->Fill(simEta, resYRZ / sigmaYRZ);
       hPullYVsPhiRZ->Fill(simPhi, resYRZ / sigmaYRZ);
     }
     if (local_) {
       hHitMult->Fill(nHitsPhi, nHitsTheta);
       ht0->Fill(t0Phi, t0Theta);
     }
   }