#include <Histograms.h>

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::ConcurrentBooker &booker, bool doall=true, bool local=true)

Private Attributes
bool	doall_

ConcurrentMonitorElement	hHitMult

ConcurrentMonitorElement	hPullAlpha

ConcurrentMonitorElement	hPullAlphaVsEta

ConcurrentMonitorElement	hPullAlphaVsPhi

ConcurrentMonitorElement	hPullBeta

ConcurrentMonitorElement	hPullBetaRZ

ConcurrentMonitorElement	hPullBetaVsEta

ConcurrentMonitorElement	hPullBetaVsEtaRZ

ConcurrentMonitorElement	hPullBetaVsPhi

ConcurrentMonitorElement	hPullBetaVsPhiRZ

ConcurrentMonitorElement	hPullX

ConcurrentMonitorElement	hPullXVsEta

ConcurrentMonitorElement	hPullXVsPhi

ConcurrentMonitorElement	hPullY

ConcurrentMonitorElement	hPullYRZ

ConcurrentMonitorElement	hPullYVsEta

ConcurrentMonitorElement	hPullYVsEtaRZ

ConcurrentMonitorElement	hPullYVsPhi

ConcurrentMonitorElement	hPullYVsPhiRZ

ConcurrentMonitorElement	hRecAlpha

ConcurrentMonitorElement	hRecBeta

ConcurrentMonitorElement	hRecBetaRZ

ConcurrentMonitorElement	hRecVsSimAlpha

ConcurrentMonitorElement	hRecVsSimBeta

ConcurrentMonitorElement	hRecVsSimBetaRZ

ConcurrentMonitorElement	hResAlpha

ConcurrentMonitorElement	hResAlphaVsEta

ConcurrentMonitorElement	hResAlphaVsPhi

ConcurrentMonitorElement	hResAlphaVsResBeta

ConcurrentMonitorElement	hResAlphaVsResX

ConcurrentMonitorElement	hResAlphaVsResY

ConcurrentMonitorElement	hResBeta

ConcurrentMonitorElement	hResBetaRZ

ConcurrentMonitorElement	hResBetaVsEta

ConcurrentMonitorElement	hResBetaVsEtaRZ

ConcurrentMonitorElement	hResBetaVsPhi

ConcurrentMonitorElement	hResBetaVsPhiRZ

ConcurrentMonitorElement	hResX

ConcurrentMonitorElement	hResXVsEta

ConcurrentMonitorElement	hResXVsPhi

ConcurrentMonitorElement	hResXVsResY

ConcurrentMonitorElement	hResY

ConcurrentMonitorElement	hResYRZ

ConcurrentMonitorElement	hResYVsEta

ConcurrentMonitorElement	hResYVsEtaRZ

ConcurrentMonitorElement	hResYVsPhi

ConcurrentMonitorElement	hResYVsPhiRZ

ConcurrentMonitorElement	hSimAlpha

ConcurrentMonitorElement	hSimBeta

ConcurrentMonitorElement	hSimBetaRZ

ConcurrentMonitorElement	ht0

bool	local_

std::string	name_

Detailed Description

Definition at line 403 of file Histograms.h.

Constructor & Destructor Documentation

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

inline

Definition at line 405 of file Histograms.h.

References DQMStore::ConcurrentBooker::book1D(), DQMStore::ConcurrentBooker::book2D(), DTRecHitClients_cfi::doall, HRes1DHit::doall_, dataset::name, 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 767 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);
     }
   }