DMRChecker Class Reference

#include <Alignment/OfflineValidation/plugins/DMRChecker.cc>

Inheritance diagram for DMRChecker:

Public Member Functions
template<typename T , typename... Args>
T *	book (const Args &...args) const
	DMRChecker (const edm::ParameterSet &pset)
template<class OBJECT_TYPE >
int	index (const std::vector< OBJECT_TYPE *> &vec, const std::string &name)
	~DMRChecker () override=default
Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::WatchRuns, edm::one::SharedResources >
	EDAnalyzer ()=default
	EDAnalyzer (const EDAnalyzer &)=delete
SerialTaskQueue *	globalLuminosityBlocksQueue () final
SerialTaskQueue *	globalRunsQueue () final
const EDAnalyzer &	operator= (const EDAnalyzer &)=delete
bool	wantsGlobalLuminosityBlocks () const noexcept final
bool	wantsGlobalRuns () const noexcept final
bool	wantsInputProcessBlocks () const noexcept final
bool	wantsProcessBlocks () const noexcept final
Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	EDAnalyzerBase ()
ModuleDescription const &	moduleDescription () const
bool	wantsStreamLuminosityBlocks () const noexcept
bool	wantsStreamRuns () const noexcept
	~EDAnalyzerBase () 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 const &)=delete
	EDConsumerBase (EDConsumerBase &&)=default
ESResolverIndex const *	esGetTokenIndices (edm::Transition iTrans) const
std::vector< ESResolverIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const
std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (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::array< std::vector< ModuleDescription const *> *, NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const *> const &labelsToDesc, std::string const &processName) const
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
EDConsumerBase &	operator= (EDConsumerBase &&)=default
bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const
void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)
ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &)
virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &)
Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
void	adjustCanvases (TCanvas &canvas, bool isBarrel)
void	analyze (const edm::Event &event, const edm::EventSetup &setup) override
void	beginJob () override
void	beginRun (edm::Run const &run, edm::EventSetup const &setup) override
std::map< unsigned int, TH1D * >	bookResidualsHistogram (TFileDirectory dir, unsigned int theNLayers, std::string resType, std::string varType, std::string detType)
std::array< TH1D *, 2 >	bookSplitDMRHistograms (TFileDirectory dir, std::string subdet, std::string vartype, bool isBarrel)
void	endJob () override
void	endRun (edm::Run const &, edm::EventSetup const &) override
void	fillByIndex (std::map< unsigned int, TH1D *> &h, unsigned int index, double x)
void	fillDMRs (const running::estimatorMap &myDetails, TH1D *DMR, TH1D *DRnR, std::array< TH1D *, 2 > DMRSplit, std::unique_ptr< PixelRegions::PixelRegionContainers > regionalDMR)
bool	isHit2D (const TrackingRecHit &hit)
void	updateOnlineMomenta (running::estimatorMap &myDetails, uint32_t theID, float the_data, float the_pull)

Private Attributes
std::map< unsigned int, TH1D * >	barrelLayersPullsX
std::map< unsigned int, TH1D * >	barrelLayersPullsY
std::map< unsigned int, TH1D * >	barrelLayersResidualsX
std::map< unsigned int, TH1D * >	barrelLayersResidualsY
edm::InputTag	BeamSpotTag_
edm::EDGetTokenT< reco::BeamSpot >	beamspotToken_
std::map< int, std::pair< int, float > >	conditionsMap_
TH1D *	DMRBPixX_
std::array< TH1D *, 2 >	DMRBPixXSplit_
TH1D *	DMRBPixY_
std::array< TH1D *, 2 >	DMRBPixYSplit_
TH1D *	DMRFPixX_
std::array< TH1D *, 2 >	DMRFPixXSplit_
TH1D *	DMRFPixY_
std::array< TH1D *, 2 >	DMRFPixYSplit_
TH1D *	DMRTEC_
TH1D *	DMRTIB_
std::array< TH1D *, 2 >	DMRTIBSplit_
TH1D *	DMRTID_
TH1D *	DMRTOB_
std::array< TH1D *, 2 >	DMRTOBSplit_
const bool	doLatencyAnalysis_
TH1D *	DRnRBPixX_
TH1D *	DRnRBPixY_
TH1D *	DRnRFPixX_
TH1D *	DRnRFPixY_
TH1D *	DRnRTEC_
TH1D *	DRnRTIB_
TH1D *	DRnRTID_
TH1D *	DRnRTOB_
std::map< unsigned int, TH1D * >	endcapDisksPullsX
std::map< unsigned int, TH1D * >	endcapDisksPullsY
std::map< unsigned int, TH1D * >	endcapDisksResidualsX
std::map< unsigned int, TH1D * >	endcapDisksResidualsY
float	etaMax_
TH1D *	eventRatesByRun_
TH1D *	evtsByTrigger_
TH1D *	fieldByRun_
edm::Service< TFileService >	fs
std::unique_ptr< Phase1PixelSummaryMap >	fullPixelmapXDMR
std::unique_ptr< Phase1PixelSummaryMap >	fullPixelmapYDMR
const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	geomToken_
TH1D *	hBPixResXPrime
TH1D *	hBPixResXPull
TH1D *	hBPixResYPrime
TH1D *	hBPixResYPull
TH1D *	hCharge
TH1D *	hchi2ndof
TH1D *	hchi2ndofhp
TH1D *	hchi2Probhp
TH1D *	hd0
TH1D *	hd0BS
TH1D *	hd0PV
TH2D *	hd0PVvseta
TH2D *	hd0PVvsphi
TH2D *	hd0PVvspt
TH2D *	hd0vseta
TH2D *	hd0vsphi
TH2D *	hd0vspt
TH1D *	hDeltaEta
TH1D *	hDeltaPhi
TH1D *	hDeltaR
TH1D *	hdxy
TH1D *	hdxyBS
TH1D *	hdxyPV
TH1D *	hdz
TH1D *	hdzBS
TH1D *	hdzPV
TH1D *	hEta
TH1D *	hEtahp
TH1D *	hEtaMinus
TH1D *	hEtaPlus
TH1D *	hFPixResXPrime
TH1D *	hFPixResXPull
TH1D *	hFPixResYPrime
TH1D *	hFPixResYPull
TH1D *	hFPixZMinusResXPrime
TH1D *	hFPixZMinusResXPull
TH1D *	hFPixZMinusResYPrime
TH1D *	hFPixZMinusResYPull
TH1D *	hFPixZPlusResXPrime
TH1D *	hFPixZPlusResXPull
TH1D *	hFPixZPlusResYPrime
TH1D *	hFPixZPlusResYPull
TH1D *	hHit
TH1D *	hHit2D
TH1D *	hHitComposition
TH1D *	hHitCountVsPhiBPix
TH1D *	hHitCountVsPhiFPix
TH1D *	hHitCountVsPhiFPixMinus
TH1D *	hHitCountVsPhiFPixPlus
TH1D *	hHitCountVsThetaBPix
TH1D *	hHitCountVsThetaFPix
TH1D *	hHitCountVsThetaFPixMinus
TH1D *	hHitCountVsThetaFPixPlus
TH1D *	hHitCountVsXBPix
TH1D *	hHitCountVsXFPix
TH1D *	hHitCountVsXFPixMinus
TH1D *	hHitCountVsXFPixPlus
TH1D *	hHitCountVsYBPix
TH1D *	hHitCountVsYFPix
TH1D *	hHitCountVsYFPixMinus
TH1D *	hHitCountVsYFPixPlus
TH1D *	hHitCountVsZBPix
TH1D *	hHitCountVsZFPix
TH1D *	hHitCountVsZFPixMinus
TH1D *	hHitCountVsZFPixPlus
TH1D *	hHithp
TH1D *	hHitMinus
TH1D *	hHitPlus
TH1D *	hitsByRun_
TH1D *	hitsinBPixByRun_
TH1D *	hitsinFPixByRun_
edm::EDGetTokenT< edm::TriggerResults >	hltresultsToken_
TH1D *	hlumi
TH1D *	hMinPt
TH1D *	hMultCand
TH1D *	hNhighPurity
TH1D *	hnhpxb
TH1D *	hnhpxe
TH1D *	hnhTEC
TH1D *	hnhTIB
TH1D *	hnhTID
TH1D *	hnhTOB
TH1D *	hNtrk
TH1D *	hNtrkZoom
TH1D *	hP
TH1D *	hPhi
TH1D *	hPhiBarrel
TH1D *	hPhiEndcapMinus
TH1D *	hPhiEndcapPlus
TH1D *	hPhihp
TH1D *	hPhiMinus
TH1D *	hPhiOverlapMinus
TH1D *	hPhiOverlapPlus
TH1D *	hPhiPlus
TH1D *	hPhp
TH1D *	hPMinus
TH1D *	hPPlus
TH1D *	hPt
TH1D *	hPthp
TH1D *	hPtMinus
TH1D *	hPtPlus
TH1D *	hQoverP
TH1D *	hQoverPZoom
TH1D *	hrun
TH1D *	hTECResXPrime
TH1D *	hTECResXPull
TH1D *	hTIBResXPrime
TH1D *	hTIBResXPull
TH1D *	hTIDResXPrime
TH1D *	hTIDResXPull
TH1D *	hTOBResXPrime
TH1D *	hTOBResXPull
TH1I *	htrkAlgo
TH1I *	htrkQuality
TH1D *	hvx
TH1D *	hvy
TH1D *	hvz
int	ievt
const bool	isCosmics_
int	itrks
edm::ESGetToken< SiStripLatency, SiStripLatencyRcd >	latencyToken_
const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	magFieldToken_
const MagneticField *	magneticField_
int	mode
TH1D *	modeByRun_
SiPixelPI::phase	phase_
std::unique_ptr< PixelRegions::PixelRegionContainers >	PixelDMRS_x_ByLayer
std::unique_ptr< PixelRegions::PixelRegionContainers >	PixelDMRS_y_ByLayer
std::unique_ptr< Phase1PixelMaps >	pixelmap
std::unique_ptr< TrackerMap >	pmap
TProfile *	pNBpixHitsVsVx
TProfile *	pNBpixHitsVsVy
TProfile *	pNBpixHitsVsVz
running::estimatorMap	resDetailsBPixX_
running::estimatorMap	resDetailsBPixY_
running::estimatorMap	resDetailsFPixX_
running::estimatorMap	resDetailsFPixY_
running::estimatorMap	resDetailsTEC_
running::estimatorMap	resDetailsTIB_
running::estimatorMap	resDetailsTID_
running::estimatorMap	resDetailsTOB_
std::map< int, std::array< int, 6 > >	runHitsMap_
std::map< int, std::pair< int, int > >	runInfoMap_
const edm::ESGetToken< RunInfo, RunInfoRcd >	runInfoToken_
edm::EDGetTokenT< reco::TrackCollection >	theTrackCollectionToken_
std::map< int, float >	timeMap_
TH1D *	tksByTrigger_
edm::InputTag	TkTag_
std::unique_ptr< TrackerMap >	tmap
const edm::ESGetToken< TrackerTopology, TrackerTopologyRcd >	topoToken_
const TrackerGeometry *	trackerGeometry_
const TrackerTopology *	trackerTopology_
TH1D *	trackRatesByRun_
TH1D *	tracksByRun_
std::map< std::string, std::pair< int, int > >	triggerMap_
edm::InputTag	TriggerResultsTag_
edm::EDGetTokenT< reco::VertexCollection >	vertexToken_
edm::InputTag	VerticesTag_
std::vector< TH1 * >	vTrack2DHistos_
std::vector< TH1 * >	vTrackHistos_
std::vector< TH1 * >	vTrackProfiles_

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept
EDGetToken	consumes (const TypeToGet &id, 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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)
template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()
template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)
template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Definition at line 150 of file DMRChecker.cc.

Constructor & Destructor Documentation

DMRChecker()

DMRChecker::DMRChecker ( const edm::ParameterSet &  pset )

inline

Definition at line 152 of file DMRChecker.cc.

References edm::BeginRun, TFileService::kSharedResource, and muonDTDigis_cfi::pset.

      : geomToken_(esConsumes<edm::Transition::BeginRun>()),
        runInfoToken_(esConsumes<edm::Transition::BeginRun>()),
        magFieldToken_(esConsumes<edm::Transition::BeginRun>()),
        topoToken_(esConsumes<edm::Transition::BeginRun>()),
        isCosmics_(pset.getParameter<bool>("isCosmics")),
        doLatencyAnalysis_(pset.getParameter<bool>("doLatencyAnalysis")) {
    usesResource(TFileService::kSharedResource);

    if (doLatencyAnalysis_) {
      latencyToken_ = esConsumes<edm::Transition::BeginRun>();
    } else {
      latencyToken_ = edm::ESGetToken<SiStripLatency, SiStripLatencyRcd>();
    }

    TkTag_ = pset.getParameter<edm::InputTag>("TkTag");
    theTrackCollectionToken_ = consumes<reco::TrackCollection>(TkTag_);

    TriggerResultsTag_ = pset.getParameter<edm::InputTag>("TriggerResultsTag");
    hltresultsToken_ = consumes<edm::TriggerResults>(TriggerResultsTag_);

    BeamSpotTag_ = pset.getParameter<edm::InputTag>("BeamSpotTag");
    beamspotToken_ = consumes<reco::BeamSpot>(BeamSpotTag_);

    VerticesTag_ = pset.getParameter<edm::InputTag>("VerticesTag");
    vertexToken_ = consumes<reco::VertexCollection>(VerticesTag_);

    // initialize conventional Tracker maps

    pmap = std::make_unique<TrackerMap>("Pixel");
    pmap->onlyPixel(true);
    pmap->setTitle("Pixel Hit entries");
    pmap->setPalette(1);

    tmap = std::make_unique<TrackerMap>("Strip");
    tmap->setTitle("Strip Hit entries");
    tmap->setPalette(1);

    // initialize Phase1 Pixel Maps

    pixelmap = std::make_unique<Phase1PixelMaps>("COLZ0 L");
    pixelmap->bookBarrelHistograms("DMRsX", "Median Residuals x-direction", "Median Residuals");
    pixelmap->bookForwardHistograms("DMRsX", "Median Residuals x-direction", "Median Residuals");

    pixelmap->bookBarrelHistograms("DMRsY", "Median Residuals y-direction", "Median Residuals");
    pixelmap->bookForwardHistograms("DMRsY", "Median Residuals y-direction", "Median Residuals");

    // set no rescale
    pixelmap->setNoRescale();

    // initialize Full Pixel Map
    fullPixelmapXDMR = std::make_unique<Phase1PixelSummaryMap>("", "DMR-x", "median of residuals [#mum]");
    fullPixelmapYDMR = std::make_unique<Phase1PixelSummaryMap>("", "DMR-y", "median of residuals [#mum]");
  }

~DMRChecker()

DMRChecker::~DMRChecker ( )

overridedefault

Member Function Documentation

adjustCanvases()

void DMRChecker::adjustCanvases ( TCanvas &  canvas, bool  isBarrel  )

inlineprivate

Definition at line 1859 of file DMRChecker.cc.

References SiPixelPI::adjustCanvasMargins(), DummyCfis::c, svgfig::canvas(), PixelRegions::IDlabels, PixelPluginsPhase0_cfi::isBarrel, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                      {
    unsigned int maxPads = isBarrel ? 4 : 12;
    for (unsigned int c = 1; c <= maxPads; c++) {
      canvas.cd(c);
      SiPixelPI::adjustCanvasMargins(canvas.cd(c), 0.06, 0.12, 0.12, 0.05);
    }

    auto ltx = TLatex();
    ltx.SetTextFont(62);
    ltx.SetTextSize(0.05);
    ltx.SetTextAlign(11);

    std::string toAppend = canvas.GetTitle();

    for (unsigned int c = 1; c <= maxPads; c++) {
      auto index = isBarrel ? c - 1 : c + 3;
      canvas.cd(c);
      ltx.DrawLatexNDC(gPad->GetLeftMargin(),
                       1 - gPad->GetTopMargin() + 0.01,
                       (PixelRegions::IDlabels.at(index) + " " + toAppend).c_str());
    }
  }

analyze()

void DMRChecker::analyze ( const edm::Event &  event, const edm::EventSetup &  setup  )

inlineoverrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 511 of file DMRChecker.cc.

References funct::abs(), accept(), PV3DBase< T, PVType, FrameType >::barePhi(), isoTrack_cff::beamSpot, cmToUm, reco::TrackBase::confirmed, DEBUG, srCondWrite_cfg::deltaPhi, hcalRecHitTable_cff::detId, PVValHelper::dxy, PVValHelper::dz, F(), HcalObjRepresent::Fill(), PVValHelper::fillByIndex(), reco::TrackBase::goodIterative, reco::TrackBase::highPurity, HLTBitAnalyser_cfi::hltresults, TrackerGeometry::idToDet(), MagneticField::inInverseGeV(), MagneticField::inTesla(), edm::HandleBase::isValid(), TrackingRecHit::isValid(), hltHgcalLayerClustersEE_cfi::kappa, reco::TrackBase::loose, run3scouting_cff::normchi2, PV3DBase< T, PVType, FrameType >::perp(), PV3DBase< T, PVType, FrameType >::phi(), PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, point, pullX(), pullY(), TrackerTopology::pxbLayer(), TrackerTopology::pxfDisk(), TrackerTopology::pxfSide(), StripSubdetector::TEC, PV3DBase< T, PVType, FrameType >::theta(), StripSubdetector::TIB, StripSubdetector::TID, reco::TrackBase::tight, StripSubdetector::TOB, HLT_2024v14_cff::track, JetHT_cfg::trackCollection, edm::TriggerNames::triggerName(), edm::TriggerNames::triggerNames(), cscTnPEfficiencyTask_cfi::trigName, SiPixelPI::two, reco::TrackBase::undefQuality, PV3DBase< T, PVType, FrameType >::x(), reco::Vertex::x(), PV3DBase< T, PVType, FrameType >::y(), reco::Vertex::y(), PV3DBase< T, PVType, FrameType >::z(), reco::Vertex::z(), and SiPixelPI::zero.

                                                                           {
    ievt++;

    edm::Handle<reco::TrackCollection> trackCollection = event.getHandle(theTrackCollectionToken_);

    GlobalPoint zeroPoint(0, 0, 0);
    if (DEBUG)
      edm::LogVerbatim("DMRChecker") << "event #" << ievt << " Event ID = " << event.id()
                                     << " magnetic field: " << magneticField_->inTesla(zeroPoint) << std::endl;

    const reco::TrackCollection tC = *(trackCollection.product());
    itrks += tC.size();

    runInfoMap_[event.run()].first += 1;
    runInfoMap_[event.run()].second += tC.size();

    if (DEBUG)
      edm::LogVerbatim("DMRChecker") << "Reconstructed " << tC.size() << " tracks" << std::endl;

    edm::Handle<edm::TriggerResults> hltresults = event.getHandle(hltresultsToken_);
    if (hltresults.isValid()) {
      const edm::TriggerNames &triggerNames_ = event.triggerNames(*hltresults);
      int ntrigs = hltresults->size();

      for (int itrig = 0; itrig != ntrigs; ++itrig) {
        const string &trigName = triggerNames_.triggerName(itrig);
        bool accept = hltresults->accept(itrig);
        if (accept == 1) {
          if (DEBUG)
            edm::LogVerbatim("DMRChecker") << trigName << " " << accept << " ,track size: " << tC.size() << endl;
          triggerMap_[trigName].first += 1;
          triggerMap_[trigName].second += tC.size();
        }
      }
    }

    hrun->Fill(event.run());
    hlumi->Fill(event.luminosityBlock());

    int nHighPurityTracks = 0;

    for (const auto &track : tC) {
      auto const &residuals = track.extra()->residuals();

      unsigned int nHit2D = 0;
      int h_index = 0;
      for (trackingRecHit_iterator iHit = track.recHitsBegin(); iHit != track.recHitsEnd(); ++iHit, ++h_index) {
        if (this->isHit2D(**iHit))
          ++nHit2D;

        double resX = residuals.residualX(h_index);
        double resY = residuals.residualY(h_index);
        double pullX = residuals.pullX(h_index);
        double pullY = residuals.pullY(h_index);

        const DetId &detId = (*iHit)->geographicalId();

        unsigned int subid = detId.subdetId();
        uint32_t detid_db = detId.rawId();

        const GeomDet *geomDet(trackerGeometry_->idToDet(detId));

        float uOrientation(-999.F), vOrientation(-999.F);
        LocalPoint lPModule(0., 0., 0.), lUDirection(1., 0., 0.), lVDirection(0., 1., 0.), lWDirection(0., 0., 1.);

        // do all the transformations here
        GlobalPoint gUDirection = geomDet->surface().toGlobal(lUDirection);
        GlobalPoint gVDirection = geomDet->surface().toGlobal(lVDirection);
        GlobalPoint gWDirection = geomDet->surface().toGlobal(lWDirection);
        GlobalPoint gPModule = geomDet->surface().toGlobal(lPModule);

        if (!(*iHit)->detUnit())
          continue;  // is it a single physical module?

        if ((*iHit)->isValid() && (subid > PixelSubdetector::PixelEndcap)) {
          if (phase_ != SiPixelPI::phase::two)
            tmap->fill(detid_db, 1);

          //LocalPoint lp = (*iHit)->localPosition();
          //LocalError le = (*iHit)->localPositionError();

          // fill DMRs and DrNRs
          if (subid == StripSubdetector::TIB) {
            uOrientation = deltaPhi(gUDirection.barePhi(), gPModule.barePhi()) >= 0. ? +1.F : -1.F;
            //vOrientation = gVDirection.z() - gPModule.z() >= 0 ? +1.F : -1.F; // not used for Strips

            // if the detid has never occcurred yet, set the local orientations
            if (resDetailsTIB_.find(detid_db) == resDetailsTIB_.end()) {
              resDetailsTIB_[detid_db].rDirection = gWDirection.perp() - gPModule.perp() >= 0 ? +1 : -1;
              resDetailsTIB_[detid_db].zDirection = gVDirection.z() - gPModule.z() >= 0 ? +1 : -1;
              resDetailsTIB_[detid_db].rOrZDirection = resDetailsTIB_[detid_db].rDirection;  // barrel (split in r)
            }

            hTIBResXPrime->Fill(uOrientation * resX * cmToUm);
            hTIBResXPull->Fill(pullX);

            // update residuals
            this->updateOnlineMomenta(resDetailsTIB_, detid_db, uOrientation * resX * cmToUm, pullX);

          } else if (subid == StripSubdetector::TOB) {
            uOrientation = deltaPhi(gUDirection.barePhi(), gPModule.barePhi()) >= 0. ? +1.F : -1.F;
            //vOrientation = gVDirection.z() - gPModule.z() >= 0 ? +1.F : -1.F; // not used for Strips

            hTOBResXPrime->Fill(uOrientation * resX * cmToUm);
            hTOBResXPull->Fill(pullX);

            // if the detid has never occcurred yet, set the local orientations
            if (resDetailsTOB_.find(detid_db) == resDetailsTOB_.end()) {
              resDetailsTOB_[detid_db].rDirection = gWDirection.perp() - gPModule.perp() >= 0 ? +1 : -1;
              resDetailsTOB_[detid_db].zDirection = gVDirection.z() - gPModule.z() >= 0 ? +1 : -1;
              resDetailsTOB_[detid_db].rOrZDirection = resDetailsTOB_[detid_db].rDirection;  // barrel (split in r)
            }

            // update residuals
            this->updateOnlineMomenta(resDetailsTOB_, detid_db, uOrientation * resX * cmToUm, pullX);

          } else if (subid == StripSubdetector::TID) {
            uOrientation = deltaPhi(gUDirection.barePhi(), gPModule.barePhi()) >= 0. ? +1.F : -1.F;
            //vOrientation = gVDirection.perp() - gPModule.perp() >= 0. ? +1.F : -1.F; // not used for Strips

            hTIDResXPrime->Fill(uOrientation * resX * cmToUm);
            hTIDResXPull->Fill(pullX);

            // update residuals
            this->updateOnlineMomenta(resDetailsTID_, detid_db, uOrientation * resX * cmToUm, pullX);

          } else if (subid == StripSubdetector::TEC) {
            uOrientation = deltaPhi(gUDirection.barePhi(), gPModule.barePhi()) >= 0. ? +1.F : -1.F;
            //vOrientation = gVDirection.perp() - gPModule.perp() >= 0. ? +1.F : -1.F; // not used for Strips

            hTECResXPrime->Fill(uOrientation * resX * cmToUm);
            hTECResXPull->Fill(pullX);

            // update residuals
            this->updateOnlineMomenta(resDetailsTEC_, detid_db, uOrientation * resX * cmToUm, pullX);
          }
        }

        const SiPixelRecHit *pixhit = dynamic_cast<const SiPixelRecHit *>(*iHit);

        if (pixhit) {
          if (pixhit->isValid()) {
            if (phase_ == SiPixelPI::phase::zero) {
              pmap->fill(detid_db, 1);
            }

            LocalPoint lp = (*iHit)->localPosition();
            //LocalError le = (*iHit)->localPositionError();
            GlobalPoint GP = geomDet->surface().toGlobal(lp);

            if ((subid == PixelSubdetector::PixelBarrel) || (subid == PixelSubdetector::PixelEndcap)) {
              // 1 = PXB, 2 = PXF
              if (subid == PixelSubdetector::PixelBarrel) {
                int layer_num = trackerTopology_->pxbLayer(detid_db);

                uOrientation = deltaPhi(gUDirection.barePhi(), gPModule.barePhi()) >= 0. ? +1.F : -1.F;
                vOrientation = gVDirection.z() - gPModule.z() >= 0 ? +1.F : -1.F;

                // if the detid has never occcurred yet, set the local orientations
                if (resDetailsBPixX_.find(detid_db) == resDetailsBPixX_.end()) {
                  resDetailsBPixX_[detid_db].rDirection = gWDirection.perp() - gPModule.perp() >= 0 ? +1 : -1;
                  resDetailsBPixX_[detid_db].zDirection = gVDirection.z() - gPModule.z() >= 0 ? +1 : -1;
                  resDetailsBPixX_[detid_db].rOrZDirection =
                      resDetailsBPixX_[detid_db].rDirection;  // barrel (split in r)
                }

                // if the detid has never occcurred yet, set the local orientations
                if (resDetailsBPixY_.find(detid_db) == resDetailsBPixY_.end()) {
                  resDetailsBPixY_[detid_db].rDirection = gWDirection.perp() - gPModule.perp() >= 0 ? +1 : -1;
                  resDetailsBPixY_[detid_db].zDirection = gVDirection.z() - gPModule.z() >= 0 ? +1 : -1;
                  resDetailsBPixY_[detid_db].rOrZDirection =
                      resDetailsBPixY_[detid_db].rDirection;  // barrel (split in r)
                }

                hHitCountVsThetaBPix->Fill(GP.theta());
                hHitCountVsPhiBPix->Fill(GP.phi());

                hHitCountVsZBPix->Fill(GP.z());
                hHitCountVsXBPix->Fill(GP.x());
                hHitCountVsYBPix->Fill(GP.y());

                hBPixResXPrime->Fill(uOrientation * resX * cmToUm);
                hBPixResYPrime->Fill(vOrientation * resY * cmToUm);
                hBPixResXPull->Fill(pullX);
                hBPixResYPull->Fill(pullY);

                if (DEBUG)
                  edm::LogVerbatim("DMRChecker") << "layer: " << layer_num << std::endl;

                // update residuals X
                this->updateOnlineMomenta(resDetailsBPixX_, detid_db, uOrientation * resX * cmToUm, pullX);

                // update residuals Y
                this->updateOnlineMomenta(resDetailsBPixY_, detid_db, vOrientation * resY * cmToUm, pullY);

                fillByIndex(barrelLayersResidualsX, layer_num, uOrientation * resX * cmToUm);
                fillByIndex(barrelLayersPullsX, layer_num, pullX);
                fillByIndex(barrelLayersResidualsY, layer_num, vOrientation * resY * cmToUm);
                fillByIndex(barrelLayersPullsY, layer_num, pullY);

              } else if (subid == PixelSubdetector::PixelEndcap) {
                uOrientation = gUDirection.perp() - gPModule.perp() >= 0 ? +1.F : -1.F;
                vOrientation = deltaPhi(gVDirection.barePhi(), gPModule.barePhi()) >= 0. ? +1.F : -1.F;

                int side_num = trackerTopology_->pxfSide(detid_db);
                int disk_num = trackerTopology_->pxfDisk(detid_db);

                int packedTopo = disk_num + 3 * (side_num - 1);

                if (DEBUG)
                  edm::LogVerbatim("DMRChecker") << "side: " << side_num << " disk: " << disk_num
                                                 << " packedTopo: " << packedTopo << " GP.z(): " << GP.z() << std::endl;

                hHitCountVsThetaFPix->Fill(GP.theta());
                hHitCountVsPhiFPix->Fill(GP.phi());

                hHitCountVsZFPix->Fill(GP.z());
                hHitCountVsXFPix->Fill(GP.x());
                hHitCountVsYFPix->Fill(GP.y());

                hFPixResXPrime->Fill(uOrientation * resX * cmToUm);
                hFPixResYPrime->Fill(vOrientation * resY * cmToUm);
                hFPixResXPull->Fill(pullX);
                hFPixResYPull->Fill(pullY);

                fillByIndex(endcapDisksResidualsX, packedTopo, uOrientation * resX * cmToUm);
                fillByIndex(endcapDisksPullsX, packedTopo, pullX);
                fillByIndex(endcapDisksResidualsY, packedTopo, vOrientation * resY * cmToUm);
                fillByIndex(endcapDisksPullsY, packedTopo, pullY);

                // if the detid has never occcurred yet, set the local orientations
                if (resDetailsFPixX_.find(detid_db) == resDetailsFPixX_.end()) {
                  resDetailsFPixX_[detid_db].rDirection = gUDirection.perp() - gPModule.perp() >= 0 ? +1 : -1;
                  resDetailsFPixX_[detid_db].zDirection = gWDirection.z() - gPModule.z() >= 0 ? +1 : -1;
                  resDetailsFPixX_[detid_db].rOrZDirection =
                      resDetailsFPixX_[detid_db].zDirection;  // endcaps (split in z)
                }

                // if the detid has never occcurred yet, set the local orientations
                if (resDetailsFPixY_.find(detid_db) == resDetailsFPixY_.end()) {
                  resDetailsFPixY_[detid_db].rDirection = gUDirection.perp() - gPModule.perp() >= 0 ? +1 : -1;
                  resDetailsFPixY_[detid_db].zDirection = gWDirection.z() - gPModule.z() >= 0 ? +1 : -1;
                  resDetailsFPixY_[detid_db].rOrZDirection =
                      resDetailsFPixY_[detid_db].zDirection;  // endcaps (split in z)
                }

                // update residuals X
                this->updateOnlineMomenta(resDetailsFPixX_, detid_db, uOrientation * resX * cmToUm, pullX);

                // update residuals Y
                this->updateOnlineMomenta(resDetailsFPixY_, detid_db, vOrientation * resY * cmToUm, pullY);

                if (side_num == 1) {
                  hHitCountVsXFPixMinus->Fill(GP.x());
                  hHitCountVsYFPixMinus->Fill(GP.y());
                  hHitCountVsZFPixMinus->Fill(GP.z());
                  hHitCountVsThetaFPixMinus->Fill(GP.theta());
                  hHitCountVsPhiFPixMinus->Fill(GP.phi());

                  hFPixZMinusResXPrime->Fill(uOrientation * resX * cmToUm);
                  hFPixZMinusResYPrime->Fill(vOrientation * resY * cmToUm);
                  hFPixZMinusResXPull->Fill(pullX);
                  hFPixZMinusResYPull->Fill(pullY);

                } else {
                  hHitCountVsXFPixPlus->Fill(GP.x());
                  hHitCountVsYFPixPlus->Fill(GP.y());
                  hHitCountVsZFPixPlus->Fill(GP.z());
                  hHitCountVsThetaFPixPlus->Fill(GP.theta());
                  hHitCountVsPhiFPixPlus->Fill(GP.phi());

                  hFPixZPlusResXPrime->Fill(uOrientation * resX * cmToUm);
                  hFPixZPlusResYPrime->Fill(vOrientation * resY * cmToUm);
                  hFPixZPlusResXPull->Fill(pullX);
                  hFPixZPlusResYPull->Fill(pullY);
                }
              }
            }
          }
        }
      }

      hHit2D->Fill(nHit2D);
      hHit->Fill(track.numberOfValidHits());
      hnhpxb->Fill(track.hitPattern().numberOfValidPixelBarrelHits());
      hnhpxe->Fill(track.hitPattern().numberOfValidPixelEndcapHits());
      hnhTIB->Fill(track.hitPattern().numberOfValidStripTIBHits());
      hnhTID->Fill(track.hitPattern().numberOfValidStripTIDHits());
      hnhTOB->Fill(track.hitPattern().numberOfValidStripTOBHits());
      hnhTEC->Fill(track.hitPattern().numberOfValidStripTECHits());

      runHitsMap_[event.run()][0] += track.hitPattern().numberOfValidPixelBarrelHits();
      runHitsMap_[event.run()][1] += track.hitPattern().numberOfValidPixelEndcapHits();
      runHitsMap_[event.run()][2] += track.hitPattern().numberOfValidStripTIBHits();
      runHitsMap_[event.run()][3] += track.hitPattern().numberOfValidStripTIDHits();
      runHitsMap_[event.run()][4] += track.hitPattern().numberOfValidStripTOBHits();
      runHitsMap_[event.run()][5] += track.hitPattern().numberOfValidStripTECHits();

      // fill hit composition histogram
      if (track.hitPattern().numberOfValidPixelBarrelHits() != 0) {
        hHitComposition->Fill(0., track.hitPattern().numberOfValidPixelBarrelHits());

        pNBpixHitsVsVx->Fill(track.vx(), track.hitPattern().numberOfValidPixelBarrelHits());
        pNBpixHitsVsVy->Fill(track.vy(), track.hitPattern().numberOfValidPixelBarrelHits());
        pNBpixHitsVsVz->Fill(track.vz(), track.hitPattern().numberOfValidPixelBarrelHits());
      }
      if (track.hitPattern().numberOfValidPixelEndcapHits() != 0) {
        hHitComposition->Fill(1., track.hitPattern().numberOfValidPixelEndcapHits());
      }
      if (track.hitPattern().numberOfValidStripTIBHits() != 0) {
        hHitComposition->Fill(2., track.hitPattern().numberOfValidStripTIBHits());
      }
      if (track.hitPattern().numberOfValidStripTIDHits() != 0) {
        hHitComposition->Fill(3., track.hitPattern().numberOfValidStripTIDHits());
      }
      if (track.hitPattern().numberOfValidStripTOBHits() != 0) {
        hHitComposition->Fill(4., track.hitPattern().numberOfValidStripTOBHits());
      }
      if (track.hitPattern().numberOfValidStripTECHits() != 0) {
        hHitComposition->Fill(5., track.hitPattern().numberOfValidStripTECHits());
      }

      hCharge->Fill(track.charge());
      hQoverP->Fill(track.qoverp());
      hQoverPZoom->Fill(track.qoverp());
      hPt->Fill(track.pt());
      hP->Fill(track.p());
      hchi2ndof->Fill(track.normalizedChi2());
      hEta->Fill(track.eta());
      hPhi->Fill(track.phi());

      if (fabs(track.eta()) < 0.8)
        hPhiBarrel->Fill(track.phi());
      if (track.eta() > 0.8 && track.eta() < 1.4)
        hPhiOverlapPlus->Fill(track.phi());
      if (track.eta() < -0.8 && track.eta() > -1.4)
        hPhiOverlapMinus->Fill(track.phi());
      if (track.eta() > 1.4)
        hPhiEndcapPlus->Fill(track.phi());
      if (track.eta() < -1.4)
        hPhiEndcapMinus->Fill(track.phi());

      hd0->Fill(track.d0());
      hdz->Fill(track.dz());
      hdxy->Fill(track.dxy());
      hvx->Fill(track.vx());
      hvy->Fill(track.vy());
      hvz->Fill(track.vz());

      htrkAlgo->Fill(track.algo());

      int myquality = -99;
      if (track.quality(reco::TrackBase::undefQuality)) {
        myquality = -1;
        htrkQuality->Fill(myquality);
      }
      if (track.quality(reco::TrackBase::loose)) {
        myquality = 0;
        htrkQuality->Fill(myquality);
      }
      if (track.quality(reco::TrackBase::tight)) {
        myquality = 1;
        htrkQuality->Fill(myquality);
      }
      if (track.quality(reco::TrackBase::highPurity) && (!isCosmics_)) {
        myquality = 2;
        htrkQuality->Fill(myquality);
        hPhp->Fill(track.p());
        hPthp->Fill(track.pt());
        hHithp->Fill(track.numberOfValidHits());
        hEtahp->Fill(track.eta());
        hPhihp->Fill(track.phi());
        hchi2ndofhp->Fill(track.normalizedChi2());
        hchi2Probhp->Fill(TMath::Prob(track.chi2(), track.ndof()));
        nHighPurityTracks++;
      }
      if (track.quality(reco::TrackBase::confirmed)) {
        myquality = 3;
        htrkQuality->Fill(myquality);
      }
      if (track.quality(reco::TrackBase::goodIterative)) {
        myquality = 4;
        htrkQuality->Fill(myquality);
      }

      // Fill 1D track histos
      static const int etaindex = this->index(vTrackHistos_, "h_tracketa");
      vTrackHistos_[etaindex]->Fill(track.eta());
      static const int phiindex = this->index(vTrackHistos_, "h_trackphi");
      vTrackHistos_[phiindex]->Fill(track.phi());
      static const int numOfValidHitsindex = this->index(vTrackHistos_, "h_trackNumberOfValidHits");
      vTrackHistos_[numOfValidHitsindex]->Fill(track.numberOfValidHits());
      static const int numOfLostHitsindex = this->index(vTrackHistos_, "h_trackNumberOfLostHits");
      vTrackHistos_[numOfLostHitsindex]->Fill(track.numberOfLostHits());

      GlobalPoint gPoint(track.vx(), track.vy(), track.vz());
      double theLocalMagFieldInInverseGeV = magneticField_->inInverseGeV(gPoint).z();
      double kappa = -track.charge() * theLocalMagFieldInInverseGeV / track.pt();

      static const int kappaindex = this->index(vTrackHistos_, "h_curvature");
      vTrackHistos_[kappaindex]->Fill(kappa);
      static const int kappaposindex = this->index(vTrackHistos_, "h_curvature_pos");
      if (track.charge() > 0)
        vTrackHistos_[kappaposindex]->Fill(fabs(kappa));
      static const int kappanegindex = this->index(vTrackHistos_, "h_curvature_neg");
      if (track.charge() < 0)
        vTrackHistos_[kappanegindex]->Fill(fabs(kappa));

      double chi2Prob = TMath::Prob(track.chi2(), track.ndof());
      double normchi2 = track.normalizedChi2();

      static const int normchi2index = this->index(vTrackHistos_, "h_normchi2");
      vTrackHistos_[normchi2index]->Fill(normchi2);
      static const int chi2index = this->index(vTrackHistos_, "h_chi2");
      vTrackHistos_[chi2index]->Fill(track.chi2());
      static const int chi2Probindex = this->index(vTrackHistos_, "h_chi2Prob");
      vTrackHistos_[chi2Probindex]->Fill(chi2Prob);
      static const int ptindex = this->index(vTrackHistos_, "h_pt");
      static const int pt2index = this->index(vTrackHistos_, "h_ptrebin");
      vTrackHistos_[ptindex]->Fill(track.pt());
      vTrackHistos_[pt2index]->Fill(track.pt());
      if (track.ptError() != 0.) {
        static const int ptResolutionindex = this->index(vTrackHistos_, "h_ptResolution");
        vTrackHistos_[ptResolutionindex]->Fill(track.ptError() / track.pt());
      }
      // Fill track profiles
      static const int d0phiindex = this->index(vTrackProfiles_, "p_d0_vs_phi");
      vTrackProfiles_[d0phiindex]->Fill(track.phi(), track.d0());
      static const int dzphiindex = this->index(vTrackProfiles_, "p_dz_vs_phi");
      vTrackProfiles_[dzphiindex]->Fill(track.phi(), track.dz());
      static const int d0etaindex = this->index(vTrackProfiles_, "p_d0_vs_eta");
      vTrackProfiles_[d0etaindex]->Fill(track.eta(), track.d0());
      static const int dzetaindex = this->index(vTrackProfiles_, "p_dz_vs_eta");
      vTrackProfiles_[dzetaindex]->Fill(track.eta(), track.dz());
      static const int chiProbphiindex = this->index(vTrackProfiles_, "p_chi2Prob_vs_phi");
      vTrackProfiles_[chiProbphiindex]->Fill(track.phi(), chi2Prob);
      static const int chiProbabsd0index = this->index(vTrackProfiles_, "p_chi2Prob_vs_d0");
      vTrackProfiles_[chiProbabsd0index]->Fill(fabs(track.d0()), chi2Prob);
      static const int chiProbabsdzindex = this->index(vTrackProfiles_, "p_chi2Prob_vs_dz");
      vTrackProfiles_[chiProbabsdzindex]->Fill(track.dz(), chi2Prob);
      static const int chiphiindex = this->index(vTrackProfiles_, "p_chi2_vs_phi");
      vTrackProfiles_[chiphiindex]->Fill(track.phi(), track.chi2());
      static const int normchiphiindex = this->index(vTrackProfiles_, "p_normchi2_vs_phi");
      vTrackProfiles_[normchiphiindex]->Fill(track.phi(), normchi2);
      static const int chietaindex = this->index(vTrackProfiles_, "p_chi2_vs_eta");
      vTrackProfiles_[chietaindex]->Fill(track.eta(), track.chi2());
      static const int normchiptindex = this->index(vTrackProfiles_, "p_normchi2_vs_pt");
      vTrackProfiles_[normchiptindex]->Fill(track.pt(), normchi2);
      static const int normchipindex = this->index(vTrackProfiles_, "p_normchi2_vs_p");
      vTrackProfiles_[normchipindex]->Fill(track.p(), normchi2);
      static const int chiProbetaindex = this->index(vTrackProfiles_, "p_chi2Prob_vs_eta");
      vTrackProfiles_[chiProbetaindex]->Fill(track.eta(), chi2Prob);
      static const int normchietaindex = this->index(vTrackProfiles_, "p_normchi2_vs_eta");
      vTrackProfiles_[normchietaindex]->Fill(track.eta(), normchi2);
      static const int kappaphiindex = this->index(vTrackProfiles_, "p_kappa_vs_phi");
      vTrackProfiles_[kappaphiindex]->Fill(track.phi(), kappa);
      static const int kappaetaindex = this->index(vTrackProfiles_, "p_kappa_vs_eta");
      vTrackProfiles_[kappaetaindex]->Fill(track.eta(), kappa);
      static const int ptResphiindex = this->index(vTrackProfiles_, "p_ptResolution_vs_phi");
      vTrackProfiles_[ptResphiindex]->Fill(track.phi(), track.ptError() / track.pt());
      static const int ptResetaindex = this->index(vTrackProfiles_, "p_ptResolution_vs_eta");
      vTrackProfiles_[ptResetaindex]->Fill(track.eta(), track.ptError() / track.pt());

      // Fill 2D track histos
      static const int etaphiindex_2d = this->index(vTrack2DHistos_, "h2_phi_vs_eta");
      vTrack2DHistos_[etaphiindex_2d]->Fill(track.eta(), track.phi());
      static const int d0phiindex_2d = this->index(vTrack2DHistos_, "h2_d0_vs_phi");
      vTrack2DHistos_[d0phiindex_2d]->Fill(track.phi(), track.d0());
      static const int dzphiindex_2d = this->index(vTrack2DHistos_, "h2_dz_vs_phi");
      vTrack2DHistos_[dzphiindex_2d]->Fill(track.phi(), track.dz());
      static const int d0etaindex_2d = this->index(vTrack2DHistos_, "h2_d0_vs_eta");
      vTrack2DHistos_[d0etaindex_2d]->Fill(track.eta(), track.d0());
      static const int dzetaindex_2d = this->index(vTrack2DHistos_, "h2_dz_vs_eta");
      vTrack2DHistos_[dzetaindex_2d]->Fill(track.eta(), track.dz());
      static const int chiphiindex_2d = this->index(vTrack2DHistos_, "h2_chi2_vs_phi");
      vTrack2DHistos_[chiphiindex_2d]->Fill(track.phi(), track.chi2());
      static const int chiProbphiindex_2d = this->index(vTrack2DHistos_, "h2_chi2Prob_vs_phi");
      vTrack2DHistos_[chiProbphiindex_2d]->Fill(track.phi(), chi2Prob);
      static const int chiProbabsd0index_2d = this->index(vTrack2DHistos_, "h2_chi2Prob_vs_d0");
      vTrack2DHistos_[chiProbabsd0index_2d]->Fill(fabs(track.d0()), chi2Prob);
      static const int normchiphiindex_2d = this->index(vTrack2DHistos_, "h2_normchi2_vs_phi");
      vTrack2DHistos_[normchiphiindex_2d]->Fill(track.phi(), normchi2);
      static const int chietaindex_2d = this->index(vTrack2DHistos_, "h2_chi2_vs_eta");
      vTrack2DHistos_[chietaindex_2d]->Fill(track.eta(), track.chi2());
      static const int chiProbetaindex_2d = this->index(vTrack2DHistos_, "h2_chi2Prob_vs_eta");
      vTrack2DHistos_[chiProbetaindex_2d]->Fill(track.eta(), chi2Prob);
      static const int normchietaindex_2d = this->index(vTrack2DHistos_, "h2_normchi2_vs_eta");
      vTrack2DHistos_[normchietaindex_2d]->Fill(track.eta(), normchi2);
      static const int kappaphiindex_2d = this->index(vTrack2DHistos_, "h2_kappa_vs_phi");
      vTrack2DHistos_[kappaphiindex_2d]->Fill(track.phi(), kappa);
      static const int kappaetaindex_2d = this->index(vTrack2DHistos_, "h2_kappa_vs_eta");
      vTrack2DHistos_[kappaetaindex_2d]->Fill(track.eta(), kappa);
      static const int normchi2kappa_2d = this->index(vTrack2DHistos_, "h2_normchi2_vs_kappa");
      vTrack2DHistos_[normchi2kappa_2d]->Fill(normchi2, kappa);

      if (DEBUG)
        edm::LogVerbatim("DMRChecker") << "filling histos" << std::endl;

      //dxy with respect to the beamspot
      reco::BeamSpot beamSpot;
      edm::Handle<reco::BeamSpot> beamSpotHandle = event.getHandle(beamspotToken_);
      if (beamSpotHandle.isValid()) {
        beamSpot = *beamSpotHandle;
        math::XYZPoint point(beamSpot.x0(), beamSpot.y0(), beamSpot.z0());
        double dxy = track.dxy(point);
        double dz = track.dz(point);
        hdxyBS->Fill(dxy);
        hd0BS->Fill(-dxy);
        hdzBS->Fill(dz);
      }

      //dxy with respect to the primary vertex
      reco::Vertex pvtx;
      edm::Handle<reco::VertexCollection> vertexHandle = event.getHandle(vertexToken_);
      double mindxy = 100.;
      double dz = 100;
      if (vertexHandle.isValid() && !isCosmics_) {
        for (reco::VertexCollection::const_iterator pvtx = vertexHandle->begin(); pvtx != vertexHandle->end(); ++pvtx) {
          math::XYZPoint mypoint(pvtx->x(), pvtx->y(), pvtx->z());
          if (abs(mindxy) > abs(track.dxy(mypoint))) {
            mindxy = track.dxy(mypoint);
            dz = track.dz(mypoint);
            if (DEBUG)
              edm::LogVerbatim("DMRChecker") << "dxy: " << mindxy << " dz: " << dz << std::endl;
          }
        }

        hdxyPV->Fill(mindxy);
        hd0PV->Fill(-mindxy);
        hdzPV->Fill(dz);

        hd0PVvsphi->Fill(track.phi(), -mindxy);
        hd0PVvseta->Fill(track.eta(), -mindxy);
        hd0PVvspt->Fill(track.pt(), -mindxy);

      } else {
        hdxyPV->Fill(100);
        hd0PV->Fill(100);
        hdzPV->Fill(100);
      }

      if (DEBUG)
        edm::LogVerbatim("DMRChecker") << "end of track loop" << std::endl;
    }

    if (DEBUG)
      edm::LogVerbatim("DMRChecker") << "end of analysis" << std::endl;

    hNtrk->Fill(tC.size());
    hNtrkZoom->Fill(tC.size());
    hNhighPurity->Fill(nHighPurityTracks);

    if (DEBUG)
      edm::LogVerbatim("DMRChecker") << "end of analysis" << std::endl;
  }

beginJob()

void DMRChecker::beginJob ( )

inlineoverrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 1141 of file DMRChecker.cc.

References reco::TrackBase::algoNames, reco::TrackBase::algoSize, DEBUG, make_classfiles::fs, mps_fire::i, M_PI, qualities, AlCaHLTBitMon_QueryRunRegistry::string, and multiplicitycorr_cfi::xBins.

                           {
    if (DEBUG)
      edm::LogVerbatim("DMRChecker") << __LINE__ << endl;

    TH1D::SetDefaultSumw2(kTRUE);

    etaMax_ = 3.;  // assign max value to eta

    // intialize counters
    ievt = 0;
    itrks = 0;

    hrun = book<TH1D>("h_run", "run", 100000, 230000, 240000);
    hlumi = book<TH1D>("h_lumi", "lumi", 1000, 0, 1000);

    // clang-format off

    hchi2ndof = book<TH1D>("h_chi2ndof", "chi2/ndf;#chi^{2}/ndf;tracks", 100, 0, 5.);
    hCharge = book<TH1D>("h_charge", "charge;Charge of the track;tracks", 5, -2.5, 2.5);
    hNtrk = book<TH1D>("h_Ntrk", "ntracks;Number of Tracks;events", 200, 0., 200.);
    hNtrkZoom = book<TH1D>("h_NtrkZoom", "Number of tracks; number of tracks;events", 10, 0., 10.);
    hNhighPurity = book<TH1D>("h_NhighPurity", "n. high purity tracks;Number of high purity tracks;events", 200, 0., 200.);

    int nAlgos = reco::TrackBase::algoSize;
    htrkAlgo = book<TH1I>("h_trkAlgo", "tracking step;iterative tracking step;tracks", nAlgos, -0.5, nAlgos - 0.5);
    for (int nbin = 1; nbin <= htrkAlgo->GetNbinsX(); nbin++) {
      htrkAlgo->GetXaxis()->SetBinLabel(nbin, reco::TrackBase::algoNames[nbin - 1].c_str());
    }

    htrkQuality = book<TH1I>("h_trkQuality", "track quality;track quality;tracks", 6, -1, 5);
    std::string qualities[7] = {"undef", "loose", "tight", "highPurity", "confirmed", "goodIterative"};
    for (int nbin = 1; nbin <= htrkQuality->GetNbinsX(); nbin++) {
      htrkQuality->GetXaxis()->SetBinLabel(nbin, qualities[nbin - 1].c_str());
    }

    hP = book<TH1D>("h_P", "Momentum;track momentum [GeV];tracks", 100, 0., 100.);
    hQoverP = book<TH1D>("h_qoverp", "Track q/p; track q/p [GeV^{-1}];tracks", 100, -1., 1.);
    hQoverPZoom = book<TH1D>("h_qoverpZoom", "Track q/p; track q/p [GeV^{-1}];tracks", 100, -0.1, 0.1);
    hPt = book<TH1D>("h_Pt", "Transverse Momentum;track p_{T} [GeV];tracks", 100, 0., 100.);
    hHit = book<TH1D>("h_nHits", "Number of hits;track n. hits;tracks", 50, -0.5, 49.5);
    hHit2D = book<TH1D>("h_nHit2D", "Number of 2D hits; number of 2D hits;tracks", 20, 0, 20);

    // Pixel

    hBPixResXPrime = book<TH1D>("h_BPixResXPrime", "BPix track X-residuals;res_{X'} [#mum];hits", 100, -1000., 1000.);
    hFPixResXPrime = book<TH1D>("h_FPixResXPrime", "FPix track X-residuals;res_{X'} [#mum];hits", 100, -1000., 1000.);
    hFPixZPlusResXPrime = book<TH1D>("h_FPixZPlusResXPrime", "FPix (Z+) track X-residuals;res_{X'} [#mum];hits", 100, -1000., 1000.);
    hFPixZMinusResXPrime = book<TH1D>("h_FPixZMinusResXPrime", "FPix (Z-) track X-residuals;res_{X'} [#mum];hits", 100, -1000., 1000.);

    hBPixResYPrime = book<TH1D>("h_BPixResYPrime", "BPix track Y-residuals;res_{Y'} [#mum];hits", 100, -1000., 1000.);
    hFPixResYPrime = book<TH1D>("h_FPixResYPrime", "FPix track Y-residuals;res_{Y'} [#mum];hits", 100, -1000., 1000.);
    hFPixZPlusResYPrime = book<TH1D>("h_FPixZPlusResYPrime", "FPix (Z+) track Y-residuals;res_{Y'} [#mum];hits", 100, -1000., 1000.);
    hFPixZMinusResYPrime = book<TH1D>("h_FPixZMinusResYPrime", "FPix (Z-) track Y-residuals;res_{Y'} [#mum];hits", 100, -1000., 1000.);

    hBPixResXPull = book<TH1D>("h_BPixResXPull", "BPix track X-pulls;res_{X'}/#sigma_{res_{X'}};hits", 100, -5., 5.);
    hFPixResXPull = book<TH1D>("h_FPixResXPull", "FPix track X-pulls;res_{X'}/#sigma_{res_{X'}};hits", 100, -5., 5.);
    hFPixZPlusResXPull = book<TH1D>("h_FPixZPlusResXPull", "FPix (Z+) track X-pulls;res_{X'}/#sigma_{res_{X'}};hits", 100, -5., 5.);
    hFPixZMinusResXPull = book<TH1D>("h_FPixZMinusResXPull", "FPix (Z-) track X-pulls;res_{X'}/#sigma_{res_{X'}};hits", 100, -5., 5.);

    hBPixResYPull = book<TH1D>("h_BPixResYPull", "BPix track Y-pulls;res_{Y'}/#sigma_{res_{Y'}};hits", 100, -5., 5.);
    hFPixResYPull = book<TH1D>("h_FPixResYPull", "FPix track Y-pulls;res_{Y'}/#sigma_{res_{Y'}};hits", 100, -5., 5.);
    hFPixZPlusResYPull = book<TH1D>("h_FPixZPlusResYPull", "FPix (Z+) track Y-pulls;res_{Y'}/#sigma_{res_{Y'}};hits", 100, -5., 5.);
    hFPixZMinusResYPull = book<TH1D>("h_FPixZMinusResYPull", "FPix (Z-) track Y-pulls;res_{Y'}/#sigma_{res_{Y'}};hits", 100, -5., 5.);

    // Strips

    hTIBResXPrime = book<TH1D>("h_TIBResXPrime", "TIB track X-residuals;res_{X'} [#mum];hits", 100, -1000., 1000.);
    hTOBResXPrime = book<TH1D>("h_TOBResXPrime", "TOB track X-residuals;res_{X'} [#mum];hits", 100, -1000., 1000.);
    hTIDResXPrime = book<TH1D>("h_TIDResXPrime", "TID track X-residuals;res_{X'} [#mum];hits", 100, -1000., 1000.);
    hTECResXPrime = book<TH1D>("h_TECResXPrime", "TEC track X-residuals;res_{X'} [#mum];hits", 100, -1000., 1000.);

    hTIBResXPull = book<TH1D>("h_TIBResXPull", "TIB track X-pulls;res_{X'}/#sigma_{res_{X'}};hits", 100, -5., 5.);
    hTOBResXPull = book<TH1D>("h_TOBResXPull", "TOB track X-pulls;res_{X'}/#sigma_{res_{X'}};hits", 100, -5., 5.);
    hTIDResXPull = book<TH1D>("h_TIDResXPull", "TID track X-pulls;res_{X'}/#sigma_{res_{X'}};hits", 100, -5., 5.);
    hTECResXPull = book<TH1D>("h_TECResXPull", "TEC track X-pulls;res_{X'}/#sigma_{res_{X'}};hits", 100, -5., 5.);

    // hit counts

    hHitCountVsZBPix = book<TH1D>("h_HitCountVsZBpix", "Number of BPix hits vs z;hit global z;hits", 60, -30, 30);
    hHitCountVsZFPix = book<TH1D>("h_HitCountVsZFpix", "Number of FPix hits vs z;hit global z;hits", 100, -100, 100);

    hHitCountVsXBPix = book<TH1D>("h_HitCountVsXBpix", "Number of BPix hits vs x;hit global x;hits", 20, -20, 20);
    hHitCountVsXFPix = book<TH1D>("h_HitCountVsXFpix", "Number of FPix hits vs x;hit global x;hits", 20, -20, 20);

    hHitCountVsYBPix = book<TH1D>("h_HitCountVsYBpix", "Number of BPix hits vs y;hit global y;hits", 20, -20, 20);
    hHitCountVsYFPix = book<TH1D>("h_HitCountVsYFpix", "Number of FPix hits vs y;hit global y;hits", 20, -20, 20);

    hHitCountVsThetaBPix = book<TH1D>("h_HitCountVsThetaBpix", "Number of BPix hits vs #theta;hit global #theta;hits", 20, 0., M_PI);
    hHitCountVsPhiBPix = book<TH1D>("h_HitCountVsPhiBpix", "Number of BPix hits vs #phi;hit global #phi;hits", 20, -M_PI, M_PI);

    hHitCountVsThetaFPix = book<TH1D>("h_HitCountVsThetaFpix", "Number of FPix hits vs #theta;hit global #theta;hits", 40, 0., M_PI);
    hHitCountVsPhiFPix = book<TH1D>("h_HitCountVsPhiFpix", "Number of FPix hits vs #phi;hit global #phi;hits", 20, -M_PI, M_PI);

    // two sides of FPix

    hHitCountVsZFPixPlus = book<TH1D>("h_HitCountVsZFPixPlus", "Number of FPix(Z+) hits vs z;hit global z;hits", 60, 15., 60);
    hHitCountVsZFPixMinus = book<TH1D>("h_HitCountVsZFPixMinus", "Number of FPix(Z-) hits vs z;hit global z;hits", 100, -60., -15.);

    hHitCountVsXFPixPlus = book<TH1D>("h_HitCountVsXFPixPlus", "Number of FPix(Z+) hits vs x;hit global x;hits", 20, -20, 20);
    hHitCountVsXFPixMinus = book<TH1D>("h_HitCountVsXFPixMinus", "Number of FPix(Z-) hits vs x;hit global x;hits", 20, -20, 20);

    hHitCountVsYFPixPlus = book<TH1D>("h_HitCountVsYFPixPlus", "Number of FPix(Z+) hits vs y;hit global y;hits", 20, -20, 20);
    hHitCountVsYFPixMinus = book<TH1D>("h_HitCountVsYFPixMinus", "Number of FPix(Z-) hits vs y;hit global y;hits", 20, -20, 20);

    hHitCountVsThetaFPixPlus = book<TH1D>("h_HitCountVsThetaFPixPlus", "Number of FPix(Z+) hits vs #theta;hit global #theta;hits", 20, 0., M_PI);
    hHitCountVsPhiFPixPlus = book<TH1D>("h_HitCountVsPhiFPixPlus","Number of FPix(Z+) hits vs #phi;hit global #phi;hits",20,-M_PI,M_PI);

    hHitCountVsThetaFPixMinus = book<TH1D>("h_HitCountVsThetaFPixMinus", "Number of FPix(Z+) hits vs #theta;hit global #theta;hits", 40, 0., M_PI);
    hHitCountVsPhiFPixMinus = book<TH1D>("h_HitCountVsPhiFPixMinus","Number of FPix(Z+) hits vs #phi;hit global #phi;hits",20,-M_PI,M_PI);

    TFileDirectory ByLayerResiduals = fs->mkdir("ByLayerResiduals");
    barrelLayersResidualsX = bookResidualsHistogram(ByLayerResiduals, 4, "X", "Res", "BPix");
    endcapDisksResidualsX = bookResidualsHistogram(ByLayerResiduals, 6, "X", "Res", "FPix");
    barrelLayersResidualsY = bookResidualsHistogram(ByLayerResiduals, 4, "Y", "Res", "BPix");
    endcapDisksResidualsY = bookResidualsHistogram(ByLayerResiduals, 6, "Y", "Res", "FPix");

    TFileDirectory ByLayerPulls = fs->mkdir("ByLayerPulls");
    barrelLayersPullsX = bookResidualsHistogram(ByLayerPulls, 4, "X", "Pull", "BPix");
    endcapDisksPullsX = bookResidualsHistogram(ByLayerPulls, 6, "X", "Pull", "FPix");
    barrelLayersPullsY = bookResidualsHistogram(ByLayerPulls, 4, "Y", "Pull", "BPix");
    endcapDisksPullsY = bookResidualsHistogram(ByLayerPulls, 6, "Y", "Pull", "FPix");

    hEta = book<TH1D>("h_Eta", "Track pseudorapidity; track #eta;tracks", 100, -etaMax_, etaMax_);
    hPhi = book<TH1D>("h_Phi", "Track azimuth; track #phi;tracks", 100, -M_PI, M_PI);

    hPhiBarrel = book<TH1D>("h_PhiBarrel", "hPhiBarrel (0<|#eta|<0.8);track #Phi;tracks", 100, -M_PI, M_PI);
    hPhiOverlapPlus = book<TH1D>("h_PhiOverlapPlus", "hPhiOverlapPlus (0.8<#eta<1.4);track #phi;tracks", 100, -M_PI, M_PI);
    hPhiOverlapMinus = book<TH1D>("h_PhiOverlapMinus", "hPhiOverlapMinus (-1.4<#eta<-0.8);track #phi;tracks", 100, -M_PI, M_PI);
    hPhiEndcapPlus = book<TH1D>("h_PhiEndcapPlus", "hPhiEndcapPlus (#eta>1.4);track #phi;track", 100, -M_PI, M_PI);
    hPhiEndcapMinus = book<TH1D>("h_PhiEndcapMinus", "hPhiEndcapMinus (#eta<1.4);track #phi;tracks", 100, -M_PI, M_PI);

    if (!isCosmics_) {
      hPhp = book<TH1D>("h_P_hp", "Momentum (high purity);track momentum [GeV];tracks", 100, 0., 100.);
      hPthp = book<TH1D>("h_Pt_hp", "Transverse Momentum (high purity);track p_{T} [GeV];tracks", 100, 0., 100.);
      hHithp = book<TH1D>("h_nHit_hp", "Number of hits (high purity);track n. hits;tracks", 30, 0, 30);
      hEtahp = book<TH1D>("h_Eta_hp", "Track pseudorapidity (high purity); track #eta;tracks", 100, -etaMax_, etaMax_);
      hPhihp = book<TH1D>("h_Phi_hp", "Track azimuth (high purity); track #phi;tracks", 100, -M_PI, M_PI);
      hchi2ndofhp = book<TH1D>("h_chi2ndof_hp", "chi2/ndf (high purity);#chi^{2}/ndf;tracks", 100, 0, 5.);
      hchi2Probhp = book<TH1D>("hchi2_Prob_hp", "#chi^{2} probability (high purity);#chi^{2}prob_{Track};Number of Tracks", 100, 0.0, 1.);

      hvx = book<TH1D>("h_vx", "Track v_{x} ; track v_{x} [cm];tracks", 100, -1.5, 1.5);
      hvy = book<TH1D>("h_vy", "Track v_{y} ; track v_{y} [cm];tracks", 100, -1.5, 1.5);
      hvz = book<TH1D>("h_vz", "Track v_{z} ; track v_{z} [cm];tracks", 100, -20., 20.);
      hd0 = book<TH1D>("h_d0", "Track d_{0} ; track d_{0} [cm];tracks", 100, -1., 1.);
      hdxy = book<TH1D>("h_dxy", "Track d_{xy}; track d_{xy} [cm]; tracks", 100, -0.5, 0.5);
      hdz = book<TH1D>("h_dz", "Track d_{z} ; track d_{z} [cm]; tracks", 100, -20, 20);

      hd0PVvsphi = book<TH2D>("h2_d0PVvsphi", "hd0PVvsphi;track #phi;track d_{0}(PV) [cm]", 160, -M_PI, M_PI, 100, -1., 1.);
      hd0PVvseta = book<TH2D>("h2_d0PVvseta", "hdPV0vseta;track #eta;track d_{0}(PV) [cm]", 160, -etaMax_, etaMax_, 100, -1., 1.);
      hd0PVvspt = book<TH2D>("h2_d0PVvspt", "hdPV0vspt;track p_{T};d_{0}(PV) [cm]", 50, 0., 100., 100, -1, 1.);

      hdxyBS = book<TH1D>("h_dxyBS", "hdxyBS; track d_{xy}(BS) [cm];tracks", 100, -0.1, 0.1);
      hd0BS = book<TH1D>("h_d0BS", "hd0BS ; track d_{0}(BS) [cm];tracks", 100, -0.1, 0.1);
      hdzBS = book<TH1D>("h_dzBS", "hdzBS ; track d_{z}(BS) [cm];tracks", 100, -12, 12);
      hdxyPV = book<TH1D>("h_dxyPV", "hdxyPV; track d_{xy}(PV) [cm];tracks", 100, -0.1, 0.1);
      hd0PV = book<TH1D>("h_d0PV", "hd0PV ; track d_{0}(PV) [cm];tracks", 100, -0.15, 0.15);
      hdzPV = book<TH1D>("h_dzPV", "hdzPV ; track d_{z}(PV) [cm];tracks", 100, -0.1, 0.1);

      hnhTIB = book<TH1D>("h_nHitTIB", "nhTIB;# hits in TIB; tracks", 20, 0., 20.);
      hnhTID = book<TH1D>("h_nHitTID", "nhTID;# hits in TID; tracks", 20, 0., 20.);
      hnhTOB = book<TH1D>("h_nHitTOB", "nhTOB;# hits in TOB; tracks", 20, 0., 20.);
      hnhTEC = book<TH1D>("h_nHitTEC", "nhTEC;# hits in TEC; tracks", 20, 0., 20.);

    } else {
      hvx = book<TH1D>("h_vx", "Track v_{x};track v_{x} [cm];tracks", 100, -100., 100.);
      hvy = book<TH1D>("h_vy", "Track v_{y};track v_{y} [cm];tracks", 100, -100., 100.);
      hvz = book<TH1D>("h_vz", "Track v_{z};track v_{z} [cm];track", 100, -100., 100.);
      hd0 = book<TH1D>("h_d0", "Track d_{0};track d_{0} [cm];track", 100, -100., 100.);
      hdxy = book<TH1D>("h_dxy", "Track d_{xy};track d_{xy} [cm];tracks", 100, -100, 100);
      hdz = book<TH1D>("h_dz", "Track d_{z};track d_{z} [cm];tracks", 100, -200, 200);

      hd0vsphi = book<TH2D>("h2_d0vsphi", "Track d_{0} vs #phi; track #phi;track d_{0} [cm]", 160, -M_PI, M_PI, 100, -100., 100.);
      hd0vseta = book<TH2D>("h2_d0vseta", "Track d_{0} vs #eta; track #eta;track d_{0} [cm]", 160, -etaMax_, etaMax_, 100, -100., 100.);
      hd0vspt = book<TH2D>("h2_d0vspt", "Track d_{0} vs p_{T};track p_{T};track d_{0} [cm]", 50, 0., 100., 100, -100, 100);

      hdxyBS = book<TH1D>("h_dxyBS", "Track d_{xy}(BS);d_{xy}(BS) [cm];tracks", 100, -100., 100.);
      hd0BS = book<TH1D>("h_d0BS", "Track d_{0}(BS);d_{0}(BS) [cm];tracks", 100, -100., 100.);
      hdzBS = book<TH1D>("h_dzBS", "Track d_{z}(BS);d_{z}(BS) [cm];tracks", 100, -100., 100.);
      hdxyPV = book<TH1D>("h_dxyPV", "Track d_{xy}(PV); d_{xy}(PV) [cm];tracks", 100, -100., 100.);
      hd0PV = book<TH1D>("h_d0PV", "Track d_{0}(PV); d_{0}(PV) [cm];tracks", 100, -100., 100.);
      hdzPV = book<TH1D>("h_dzPV", "Track d_{z}(PV); d_{z}(PV) [cm];tracks", 100, -100., 100.);

      hnhTIB = book<TH1D>("h_nHitTIB", "nhTIB;# hits in TIB; tracks", 30, 0., 30.);
      hnhTID = book<TH1D>("h_nHitTID", "nhTID;# hits in TID; tracks", 30, 0., 30.);
      hnhTOB = book<TH1D>("h_nHitTOB", "nhTOB;# hits in TOB; tracks", 30, 0., 30.);
      hnhTEC = book<TH1D>("h_nHitTEC", "nhTEC;# hits in TEC; tracks", 30, 0., 30.);
    }

    hnhpxb = book<TH1D>("h_nHitPXB", "nhpxb;# hits in Pixel Barrel; tracks", 10, 0., 10.);
    hnhpxe = book<TH1D>("h_nHitPXE", "nhpxe;# hits in Pixel Endcap; tracks", 10, 0., 10.);

    hHitComposition = book<TH1D>("h_hitcomposition", "track hit composition;;# hits", 6, -0.5, 5.5);
    pNBpixHitsVsVx = book<TProfile>("p_NpixHits_vs_Vx", "n. Barrel Pixel hits vs. v_{x};v_{x} (cm);n. BPix hits", 20, -20, 20);
    pNBpixHitsVsVy = book<TProfile>("p_NpixHits_vs_Vy", "n. Barrel Pixel hits vs. v_{y};v_{y} (cm);n. BPix hits", 20, -20, 20);
    pNBpixHitsVsVz = book<TProfile>("p_NpixHits_vs_Vz", "n. Barrel Pixel hits vs. v_{z};v_{z} (cm);n. BPix hits", 20, -100, 100);

    std::string dets[6] = {"PXB", "PXF", "TIB", "TID", "TOB", "TEC"};
    for (int i = 1; i <= hHitComposition->GetNbinsX(); i++) {
      hHitComposition->GetXaxis()->SetBinLabel(i, dets[i - 1].c_str());
    }

    vTrackHistos_.push_back(book<TH1F>("h_tracketa", "Track #eta;#eta_{Track};Number of Tracks", 90, -etaMax_, etaMax_));
    vTrackHistos_.push_back(book<TH1F>("h_trackphi", "Track #phi;#phi_{Track};Number of Tracks", 90, -M_PI, M_PI));
    vTrackHistos_.push_back(book<TH1F>("h_trackNumberOfValidHits", "Track # of valid hits;# of valid hits _{Track};Number of Tracks", 40, 0., 40.));
    vTrackHistos_.push_back(book<TH1F>("h_trackNumberOfLostHits", "Track # of lost hits;# of lost hits _{Track};Number of Tracks", 10, 0., 10.));
    vTrackHistos_.push_back(book<TH1F>("h_curvature", "Curvature #kappa;#kappa_{Track};Number of Tracks", 100, -.05, .05));
    vTrackHistos_.push_back(book<TH1F>("h_curvature_pos", "Curvature |#kappa| Positive Tracks;|#kappa_{pos Track}|;Number of Tracks", 100, .0, .05));
    vTrackHistos_.push_back(book<TH1F>("h_curvature_neg", "Curvature |#kappa| Negative Tracks;|#kappa_{neg Track}|;Number of Tracks", 100, .0, .05));
    vTrackHistos_.push_back(book<TH1F>("h_diff_curvature", "Curvature |#kappa| Tracks Difference;|#kappa_{Track}|;# Pos Tracks - # Neg Tracks", 100,.0,.05));

    vTrackHistos_.push_back(book<TH1F>("h_chi2", "Track #chi^{2};#chi^{2}_{Track};Number of Tracks", 500, -0.01, 500.));
    vTrackHistos_.push_back(book<TH1F>("h_chi2Prob", "#chi^{2} probability;Track Prob(#chi^{2},ndof);Number of Tracks", 100, 0.0, 1.));
    vTrackHistos_.push_back(book<TH1F>("h_normchi2", "#chi^{2}/ndof;#chi^{2}/ndof;Number of Tracks", 100, -0.01, 10.));

    //variable binning for chi2/ndof vs. pT
    double xBins[19] = {0., 0.15, 0.5, 1., 1.5, 2., 2.5, 3., 3.5, 4., 4.5, 5., 7., 10., 15., 25., 40., 100., 200.};
    vTrackHistos_.push_back(book<TH1F>("h_pt", "Track p_{T};p_{T}^{track} [GeV];Number of Tracks", 250, 0., 250));
    vTrackHistos_.push_back(book<TH1F>("h_ptrebin", "Track p_{T};p_{T}^{track} [GeV];Number of Tracks", 18, xBins));

    vTrackHistos_.push_back(book<TH1F>("h_ptResolution", "#delta_{p_{T}}/p_{T}^{track};#delta_{p_{T}}/p_{T}^{track};Number of Tracks", 100, 0., 0.5));
    vTrackProfiles_.push_back(book<TProfile>("p_d0_vs_phi", "Transverse Impact Parameter vs. #phi;#phi_{Track};#LT d_{0} #GT [cm]", 100, -M_PI, M_PI));
    vTrackProfiles_.push_back(book<TProfile>("p_dz_vs_phi", "Longitudinal Impact Parameter vs. #phi;#phi_{Track};#LT d_{z} #GT [cm]", 100, -M_PI, M_PI));
    vTrackProfiles_.push_back(book<TProfile>("p_d0_vs_eta", "Transverse Impact Parameter vs. #eta;#eta_{Track};#LT d_{0} #GT [cm]", 100, -etaMax_, etaMax_));
    vTrackProfiles_.push_back(book<TProfile>("p_dz_vs_eta", "Longitudinal Impact Parameter vs. #eta;#eta_{Track};#LT d_{z} #GT [cm]", 100, -etaMax_, etaMax_));
    vTrackProfiles_.push_back(book<TProfile>("p_chi2_vs_phi", "#chi^{2} vs. #phi;#phi_{Track};#LT #chi^{2} #GT", 100, -M_PI, M_PI));
    vTrackProfiles_.push_back(book<TProfile>("p_chi2Prob_vs_phi","#chi^{2} probablility vs. #phi;#phi_{Track};#LT #chi^{2} probability#GT",100,-M_PI,M_PI));
    vTrackProfiles_.push_back(book<TProfile>("p_chi2Prob_vs_d0", "#chi^{2} probablility vs. |d_{0}|;|d_{0}|[cm];#LT #chi^{2} probability#GT", 100, 0, 80));
    vTrackProfiles_.push_back(book<TProfile>("p_chi2Prob_vs_dz", "#chi^{2} probablility vs. dz;d_{z} [cm];#LT #chi^{2} probability#GT", 100, -30, 30));
    vTrackProfiles_.push_back(book<TProfile>("p_normchi2_vs_phi", "#chi^{2}/ndof vs. #phi;#phi_{Track};#LT #chi^{2}/ndof #GT", 100, -M_PI, M_PI));
    vTrackProfiles_.push_back(book<TProfile>("p_chi2_vs_eta", "#chi^{2} vs. #eta;#eta_{Track};#LT #chi^{2} #GT", 100, -etaMax_, etaMax_));
    vTrackProfiles_.push_back(book<TProfile>("p_normchi2_vs_pt", "norm #chi^{2} vs. p_{T}_{Track}; p_{T}_{Track};#LT #chi^{2}/ndof #GT", 18, xBins));
    vTrackProfiles_.push_back(book<TProfile>("p_normchi2_vs_p", "#chi^{2}/ndof vs. p_{Track};p_{Track};#LT #chi^{2}/ndof #GT", 18, xBins));
    vTrackProfiles_.push_back(book<TProfile>("p_chi2Prob_vs_eta","#chi^{2} probability vs. #eta;#eta_{Track};#LT #chi^{2} probability #GT",100,-etaMax_, etaMax_));
    vTrackProfiles_.push_back(book<TProfile>("p_normchi2_vs_eta", "#chi^{2}/ndof vs. #eta;#eta_{Track};#LT #chi^{2}/ndof #GT", 100, -etaMax_, etaMax_));
    vTrackProfiles_.push_back(book<TProfile>("p_kappa_vs_phi", "#kappa vs. #phi;#phi_{Track};#kappa", 100, -M_PI, M_PI));
    vTrackProfiles_.push_back(book<TProfile>("p_kappa_vs_eta", "#kappa vs. #eta;#eta_{Track};#kappa", 100, -etaMax_, etaMax_));
    vTrackProfiles_.push_back(book<TProfile>("p_ptResolution_vs_phi","#delta_{p_{T}}/p_{T}^{track};#phi^{track};#delta_{p_{T}}/p_{T}^{track}", 100,-M_PI,M_PI));
    vTrackProfiles_.push_back(book<TProfile>("p_ptResolution_vs_eta","#delta_{p_{T}}/p_{T}^{track};#eta^{track};#delta_{p_{T}}/p_{T}^{track}", 100, -etaMax_, etaMax_));
    vTrack2DHistos_.push_back(book<TH2F>("h2_d0_vs_phi","Transverse Impact Parameter vs. #phi;#phi_{Track};d_{0} [cm]", 100, -M_PI, M_PI, 100, -1., 1.));
    vTrack2DHistos_.push_back(book<TH2F>("h2_phi_vs_eta", "Track #phi vs. #eta;#eta_{Track};#phi_{Track}",50, -etaMax_, etaMax_, 50, -M_PI, M_PI));
    vTrack2DHistos_.push_back(book<TH2F>("h2_dz_vs_phi","Longitudinal Impact Parameter vs. #phi;#phi_{Track};d_{z} [cm]",100,-M_PI,M_PI,100,-100.,100.));
    vTrack2DHistos_.push_back(book<TH2F>("h2_d0_vs_eta","Transverse Impact Parameter vs. #eta;#eta_{Track};d_{0} [cm]", 100, -etaMax_, etaMax_, 100, -1., 1.));
    vTrack2DHistos_.push_back(book<TH2F>("h2_dz_vs_eta","Longitudinal Impact Parameter vs. #eta;#eta_{Track};d_{z} [cm]",100, -etaMax_, etaMax_, 100,-100.,100.));
    vTrack2DHistos_.push_back(book<TH2F>("h2_chi2_vs_phi", "#chi^{2} vs. #phi;#phi_{Track};#chi^{2}", 100, -M_PI, M_PI, 500, 0., 500.));
    vTrack2DHistos_.push_back(book<TH2F>("h2_chi2Prob_vs_phi","#chi^{2} probability vs. #phi;#phi_{Track};#chi^{2} probability",100,-M_PI,M_PI,100,0.,1.));
    vTrack2DHistos_.push_back(book<TH2F>("h2_chi2Prob_vs_d0","#chi^{2} probability vs. |d_{0}|;|d_{0}| [cm];#chi^{2} probability",100,0,80,100,0.,1.));
    vTrack2DHistos_.push_back(book<TH2F>("h2_normchi2_vs_phi", "#chi^{2}/ndof vs. #phi;#phi_{Track};#chi^{2}/ndof", 100, -M_PI, M_PI, 100, 0., 10.));
    vTrack2DHistos_.push_back(book<TH2F>("h2_chi2_vs_eta", "#chi^{2} vs. #eta;#eta_{Track};#chi^{2}", 100, -etaMax_, etaMax_, 500, 0., 500.));
    vTrack2DHistos_.push_back(book<TH2F>("h2_chi2Prob_vs_eta","#chi^{2} probaility vs. #eta;#eta_{Track};#chi^{2} probability",100,-M_PI,M_PI,100,0.,1.));
    vTrack2DHistos_.push_back(book<TH2F>("h2_normchi2_vs_eta", "#chi^{2}/ndof vs. #eta;#eta_{Track};#chi^{2}/ndof", 100, -etaMax_, etaMax_, 100, 0., 10.));
    vTrack2DHistos_.push_back(book<TH2F>("h2_kappa_vs_phi", "#kappa vs. #phi;#phi_{Track};#kappa", 100, -M_PI, M_PI, 100, .0, .05));
    vTrack2DHistos_.push_back(book<TH2F>("h2_kappa_vs_eta", "#kappa vs. #eta;#eta_{Track};#kappa", 100, -etaMax_, etaMax_, 100, .0, .05));
    vTrack2DHistos_.push_back(book<TH2F>("h2_normchi2_vs_kappa", "#kappa vs. #chi^{2}/ndof;#chi^{2}/ndof;#kappa", 100, 0., 10, 100, -.03, .03));
    // clang-format on

    // create the full maps
    fullPixelmapXDMR->createTrackerBaseMap();
    fullPixelmapYDMR->createTrackerBaseMap();

  }  //beginJob

beginRun()

void DMRChecker::beginRun ( edm::Run const &  run, edm::EventSetup const &  setup  )

inlineoverrideprivate

Definition at line 1068 of file DMRChecker.cc.

References MagneticField::inTesla(), TrackerGeometry::isThere(), PV3DBase< T, PVType, FrameType >::mag(), ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, create_idmaps::n, SiPixelPI::one, GeomDetEnumerators::P1PXB, GeomDetEnumerators::P1PXEC, GeomDetEnumerators::P2PXB, GeomDetEnumerators::P2PXEC, writedatasetfile::run, dqm_diff::seconds, singleTopDQM_cfi::setup, SiStripLatency::singleReadOutMode(), edmLumisInFiles::summary, SiPixelPI::two, and SiPixelPI::zero.

  {
    // initialize runInfoMap_
    runInfoMap_[run.run()].first = 0;
    runInfoMap_[run.run()].second = 0;

    // initialize runHitsMap
    for (int n : {0, 1, 2, 3, 4, 5}) {
      runHitsMap_[run.run()][n] = 0;  // 6 subdets
    }

    // Magnetic Field setup
    magneticField_ = &setup.getData(magFieldToken_);
    float B_ = magneticField_->inTesla(GlobalPoint(0, 0, 0)).mag();

    edm::LogInfo("DMRChecker") << "run number:" << run.run() << " magnetic field: " << B_ << " [T]" << std::endl;

    const RunInfo *summary = &setup.getData(runInfoToken_);
    time_t start_time = summary->m_start_time_ll;
    ctime(&start_time);
    time_t end_time = summary->m_stop_time_ll;
    ctime(&end_time);

    float average_current = summary->m_avg_current;
    float uptimeInSeconds = summary->m_run_intervall_micros;
    edm::LogVerbatim("DMRChecker") << " start_time: " << start_time << " ( " << summary->m_start_time_str << " )"
                                   << " | end_time: " << end_time << " ( " << summary->m_stop_time_str << " )"
                                   << " | average current: " << average_current
                                   << " | uptime in seconds: " << uptimeInSeconds << std::endl;

    double seconds = difftime(end_time, start_time) / 1.0e+6;  // convert from micros-seconds
    edm::LogVerbatim("DMRChecker") << "time difference: " << seconds << " s" << std::endl;
    timeMap_[run.run()] = seconds;

    // set geometry and topology
    trackerGeometry_ = &setup.getData(geomToken_);
    if (trackerGeometry_->isThere(GeomDetEnumerators::P2PXB) || trackerGeometry_->isThere(GeomDetEnumerators::P2PXEC)) {
      phase_ = SiPixelPI::phase::two;
    } else if (trackerGeometry_->isThere(GeomDetEnumerators::P1PXB) ||
               trackerGeometry_->isThere(GeomDetEnumerators::P1PXEC)) {
      phase_ = SiPixelPI::phase::one;
    } else {
      phase_ = SiPixelPI::phase::zero;
    }

    trackerTopology_ = &setup.getData(topoToken_);

    // if it's a phase-2 geometry there are no phase-1 conditions
    if (phase_ == SiPixelPI::phase::two) {
      mode = 0;
    } else {
      if (doLatencyAnalysis_) {
        //SiStrip Latency
        const SiStripLatency *apvlat = &setup.getData(latencyToken_);
        if (apvlat->singleReadOutMode() == 1) {
          mode = 1;  // peak mode
        } else if (apvlat->singleReadOutMode() == 0) {
          mode = -1;  // deco mode
        }
      } else {
        mode = 0.;
      }
    }

    conditionsMap_[run.run()].first = mode;
    conditionsMap_[run.run()].second = B_;
  }

book()

template<typename T , typename... Args>

T* DMRChecker::book ( const Args &...  args ) const

inline

Definition at line 229 of file DMRChecker.cc.

References writedatasetfile::args, make_classfiles::fs, and submitPVValidationJobs::t.

                                     {
    T *t = fs->make<T>(args...);
    return t;
  }

bookResidualsHistogram()

std::map<unsigned int, TH1D *> DMRChecker::bookResidualsHistogram ( TFileDirectory  dir, unsigned int  theNLayers, std::string  resType, std::string  varType, std::string  detType  )

inlineprivate

Definition at line 1960 of file DMRChecker.cc.

References DeadROC_duringRun::dir, h, mps_fire::i, TH2PolyOfflineMaps::limits, ALPAKA_ACCELERATOR_NAMESPACE::ecal::reconstruction::internal::barrel::side(), AlCaHLTBitMon_QueryRunRegistry::string, and dumpRecoGeometry_cfg::varType.

                                                                                                            {
    TH1F::SetDefaultSumw2(kTRUE);

    std::pair<double, double> limits;

    if (varType.find("Res") != std::string::npos) {
      limits = std::make_pair(-1000., 1000);
    } else {
      limits = std::make_pair(-3., 3.);
    }

    std::map<unsigned int, TH1D *> h;

    for (unsigned int i = 1; i <= theNLayers; i++) {
      const char *name_;
      const char *title_;
      std::string xAxisTitle_;

      if (varType.find("Res") != std::string::npos) {
        xAxisTitle_ = fmt::sprintf("res_{%s'} [#mum]", resType);
      } else {
        xAxisTitle_ = fmt::sprintf("res_{%s'}/#sigma_{res_{%s`}}", resType, resType);
      }

      unsigned int side = -1;
      if (detType.find("FPix") != std::string::npos) {
        side = (i - 1) / 3 + 1;
        unsigned int plane = (i - 1) % 3 + 1;

        std::string theSide = "";
        if (side == 1) {
          theSide = "Z-";
        } else {
          theSide = "Z+";
        }

        name_ = Form("h_%s%s%s_side%i_disk%i", detType.c_str(), varType.c_str(), resType.c_str(), side, plane);
        title_ = Form("%s (%s, disk %i) track %s-%s;%s;hits",
                      detType.c_str(),
                      theSide.c_str(),
                      plane,
                      resType.c_str(),
                      varType.c_str(),
                      xAxisTitle_.c_str());

      } else {
        name_ = Form("h_%s%s%s_layer%i", detType.c_str(), varType.c_str(), resType.c_str(), i);
        title_ = Form("%s (layer %i) track %s-%s;%s;hits",
                      detType.c_str(),
                      i,
                      resType.c_str(),
                      varType.c_str(),
                      xAxisTitle_.c_str());

        //edm::LogPrint("DMRChecker")<<"bookResidualsHistogram(): "<<i<<" layer:"<<i<<std::endl;
      }

      h[i] = dir.make<TH1D>(name_, title_, 100, limits.first, limits.second);
    }

    return h;
  }

bookSplitDMRHistograms()

std::array<TH1D *, 2> DMRChecker::bookSplitDMRHistograms ( TFileDirectory  dir, std::string  subdet, std::string  vartype, bool  isBarrel  )

inlineprivate

Definition at line 1928 of file DMRChecker.cc.

References DeadROC_duringRun::dir, mps_fire::i, PixelPluginsPhase0_cfi::isBarrel, MillePedeFileConverter_cfg::out, and Validation_hcalonly_cfi::sign.

                                                              {
    TH1F::SetDefaultSumw2(kTRUE);

    std::array<TH1D *, 2> out;
    std::array<std::string, 2> sign_name = {{"plus", "minus"}};
    std::array<std::string, 2> sign = {{">0", "<0"}};
    for (unsigned int i = 0; i < 2; i++) {
      const char *name_;
      const char *title_;
      const char *axisTitle_;

      if (isBarrel) {
        name_ = Form("DMR%s_%s_rDir%s", subdet.c_str(), vartype.c_str(), sign_name[i].c_str());
        title_ = Form("Split DMR of %s-%s (rDir%s)", subdet.c_str(), vartype.c_str(), sign[i].c_str());
        axisTitle_ = Form("mean of %s-residuals (rDir%s);modules", vartype.c_str(), sign[i].c_str());
      } else {
        name_ = Form("DMR%s_%s_zDir%s", subdet.c_str(), vartype.c_str(), sign_name[i].c_str());
        title_ = Form("Split DMR of %s-%s (zDir%s)", subdet.c_str(), vartype.c_str(), sign[i].c_str());
        axisTitle_ = Form("mean of %s-residuals (zDir%s);modules", vartype.c_str(), sign[i].c_str());
      }

      out[i] = dir.make<TH1D>(name_, fmt::sprintf("%s;%s", title_, axisTitle_).c_str(), 100., -200, 200);
    }
    return out;
  }

endJob()

void DMRChecker::endJob ( void  )

inlineoverrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 1402 of file DMRChecker.cc.

References PixelRegions::attachedDets(), DummyCfis::c, ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), gather_cfg::cout, DEBUG, mps_splice::entry, dqmdumpme::first, alignBH_cfg::fixed, StandaloneTrackerTopology::fromTrackerParametersXMLFile(), make_classfiles::fs, contentValuesFiles::fullPath, mps_fire::i, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, PixelRegions::L1, TFileDirectory::make(), SiPixelPI::one, SiPixelPI::PhaseInfo::pathToTopoXML(), SiPixelPI::PhaseInfo::phase(), crab_NZS2018C_1::runRange, edm::second(), jetUpdater_cfi::sort, mathSSE::sqrt(), fireworks::subdets, and SiPixelPI::zero.

Referenced by o2olib.O2ORunMgr::executeJob().

                         {
    edm::LogPrint("DMRChecker") << "*******************************" << std::endl;
    edm::LogPrint("DMRChecker") << "Events run in total: " << ievt << std::endl;
    edm::LogPrint("DMRChecker") << "n. tracks: " << itrks << std::endl;
    edm::LogPrint("DMRChecker") << "*******************************" << std::endl;

    int nFiringTriggers = !triggerMap_.empty() ? triggerMap_.size() : 1;
    edm::LogPrint("DMRChecker") << "firing triggers: " << triggerMap_.size() << std::endl;
    edm::LogPrint("DMRChecker") << "*******************************" << std::endl;

    tksByTrigger_ =
        book<TH1D>("tksByTrigger", "tracks by HLT path;;% of # traks", nFiringTriggers, -0.5, nFiringTriggers - 0.5);
    evtsByTrigger_ =
        book<TH1D>("evtsByTrigger", "events by HLT path;;% of # events", nFiringTriggers, -0.5, nFiringTriggers - 0.5);

    if (DEBUG)
      edm::LogPrint("DMRChecker") << __FILE__ << "@" << __FUNCTION__ << " L-" << __LINE__ << std::endl;

    int i = 0;
    for (const auto &it : triggerMap_) {
      i++;

      double trkpercent = ((it.second).second) * 100. / double(itrks);
      double evtpercent = ((it.second).first) * 100. / double(ievt);

      std::cout.precision(4);

      edm::LogPrint("DMRChecker") << "HLT path: " << std::setw(60) << left << it.first << " | events firing: " << right
                                  << std::setw(8) << (it.second).first << " (" << setw(8) << fixed << evtpercent << "%)"
                                  << " | tracks collected: " << std::setw(10) << (it.second).second << " (" << setw(8)
                                  << fixed << trkpercent << "%)";

      tksByTrigger_->SetBinContent(i, trkpercent);
      tksByTrigger_->GetXaxis()->SetBinLabel(i, (it.first).c_str());

      evtsByTrigger_->SetBinContent(i, evtpercent);
      evtsByTrigger_->GetXaxis()->SetBinLabel(i, (it.first).c_str());
    }

    if (DEBUG)
      edm::LogPrint("DMRChecker") << __FILE__ << "@" << __FUNCTION__ << " L-" << __LINE__ << std::endl;

    int nRuns = conditionsMap_.size();
    if (nRuns < 1)
      return;

    vector<int> theRuns_;
    theRuns_.reserve(conditionsMap_.size());
    for (const auto &it : conditionsMap_) {
      theRuns_.push_back(it.first);
    }

    std::sort(theRuns_.begin(), theRuns_.end());
    int runRange = theRuns_.back() - theRuns_.front() + 1;

    edm::LogPrint("DMRChecker") << "*******************************" << std::endl;
    edm::LogPrint("DMRChecker") << "first run: " << theRuns_.front() << std::endl;
    edm::LogPrint("DMRChecker") << "last run:  " << theRuns_.back() << std::endl;
    edm::LogPrint("DMRChecker") << "considered runs: " << nRuns << std::endl;
    edm::LogPrint("DMRChecker") << "*******************************" << std::endl;

    modeByRun_ = book<TH1D>("modeByRun",
                            "Strip APV mode by run number;;APV mode (-1=deco,+1=peak)",
                            runRange,
                            theRuns_.front() - 0.5,
                            theRuns_.back() + 0.5);
    fieldByRun_ = book<TH1D>("fieldByRun",
                             "CMS B-field intensity by run number;;B-field intensity [T]",
                             runRange,
                             theRuns_.front() - 0.5,
                             theRuns_.back() + 0.5);

    tracksByRun_ = book<TH1D>("tracksByRun",
                              "n. AlCaReco Tracks by run number;;n. of tracks",
                              runRange,
                              theRuns_.front() - 0.5,
                              theRuns_.back() + 0.5);
    hitsByRun_ = book<TH1D>(
        "histByRun", "n. of hits by run number;;n. of hits", runRange, theRuns_.front() - 0.5, theRuns_.back() + 0.5);

    trackRatesByRun_ = book<TH1D>("trackRatesByRun",
                                  "rate of AlCaReco Tracks by run number;;n. of tracks/s",
                                  runRange,
                                  theRuns_.front() - 0.5,
                                  theRuns_.back() + 0.5);
    eventRatesByRun_ = book<TH1D>("eventRatesByRun",
                                  "rate of AlCaReco Events by run number;;n. of events/s",
                                  runRange,
                                  theRuns_.front() - 0.5,
                                  theRuns_.back() + 0.5);

    hitsinBPixByRun_ = book<TH1D>("histinBPixByRun",
                                  "n. of hits in BPix by run number;;n. of BPix hits",
                                  runRange,
                                  theRuns_.front() - 0.5,
                                  theRuns_.back() + 0.5);
    hitsinFPixByRun_ = book<TH1D>("histinFPixByRun",
                                  "n. of hits in FPix by run number;;n. of FPix hits",
                                  runRange,
                                  theRuns_.front() - 0.5,
                                  theRuns_.back() + 0.5);

    for (const auto &the_r : theRuns_) {
      if (conditionsMap_.find(the_r)->second.first != 0) {
        auto indexing = (the_r - theRuns_.front()) + 1;
        double runTime = timeMap_.find(the_r)->second;

        edm::LogPrint("DMRChecker") << "run:" << the_r << " | isPeak: " << std::setw(4)
                                    << conditionsMap_.find(the_r)->second.first
                                    << "| B-field: " << conditionsMap_.find(the_r)->second.second << " [T]"
                                    << "| events: " << setw(10) << runInfoMap_.find(the_r)->second.first
                                    << "(rate: " << setw(10) << (runInfoMap_.find(the_r)->second.first) / runTime
                                    << " ev/s)"
                                    << ", tracks " << setw(10) << runInfoMap_.find(the_r)->second.second
                                    << "(rate: " << setw(10) << (runInfoMap_.find(the_r)->second.second) / runTime
                                    << " trk/s)" << std::endl;

        // int the_bin = modeByRun_->GetXaxis()->FindBin(the_r);
        modeByRun_->SetBinContent(indexing, conditionsMap_.find(the_r)->second.first);
        modeByRun_->GetXaxis()->SetBinLabel(indexing, Form("%d", the_r));
        fieldByRun_->SetBinContent(indexing, conditionsMap_.find(the_r)->second.second);
        fieldByRun_->GetXaxis()->SetBinLabel(indexing, Form("%d", the_r));

        tracksByRun_->SetBinContent(indexing, runInfoMap_.find(the_r)->second.first);
        tracksByRun_->GetXaxis()->SetBinLabel(indexing, Form("%d", the_r));
        hitsByRun_->SetBinContent(indexing, runInfoMap_.find(the_r)->second.second);
        hitsByRun_->GetXaxis()->SetBinLabel(indexing, Form("%d", the_r));

        hitsinBPixByRun_->SetBinContent(indexing, (runHitsMap_.find(the_r)->second)[0]);
        hitsinBPixByRun_->GetXaxis()->SetBinLabel(indexing, Form("%d", the_r));
        hitsinFPixByRun_->SetBinContent(indexing, (runHitsMap_.find(the_r)->second)[1]);
        hitsinFPixByRun_->GetXaxis()->SetBinLabel(indexing, Form("%d", the_r));

        trackRatesByRun_->SetBinContent(indexing, (runInfoMap_.find(the_r)->second.second) / runTime);
        trackRatesByRun_->GetXaxis()->SetBinLabel(indexing, Form("%d", the_r));
        eventRatesByRun_->SetBinContent(indexing, (runInfoMap_.find(the_r)->second.first) / runTime);
        eventRatesByRun_->GetXaxis()->SetBinLabel(indexing, Form("%d", the_r));

        constexpr const char *subdets[]{"BPix", "FPix", "TIB", "TID", "TOB", "TEC"};

        edm::LogPrint("DMRChecker") << "*******************************" << std::endl;
        edm::LogPrint("DMRChecker") << "Hits by SubDetector" << std::endl;
        int si = 0;
        for (const auto &entry : runHitsMap_.find(the_r)->second) {
          edm::LogPrint("DMRChecker") << subdets[si] << " " << entry << std::endl;
          si++;
        }
        edm::LogPrint("DMRChecker") << "*******************************" << std::endl;
      }

      // modeByRun_->GetXaxis()->SetBinLabel(the_r-theRuns_[0]+1,(const char*)the_r);
    }

    if (DEBUG)
      edm::LogPrint("DMRChecker") << __FILE__ << "@" << __FUNCTION__ << " L-" << __LINE__ << std::endl;

    // DMRs

    TFileDirectory DMeanR = fs->mkdir("DMRs");

    DMRBPixX_ = DMeanR.make<TH1D>("DMRBPix-X", "DMR of BPix-X;mean of X-residuals;modules", 100., -200, 200);
    DMRBPixY_ = DMeanR.make<TH1D>("DMRBPix-Y", "DMR of BPix-Y;mean of Y-residuals;modules", 100., -200, 200);

    DMRFPixX_ = DMeanR.make<TH1D>("DMRFPix-X", "DMR of FPix-X;mean of X-residuals;modules", 100., -200, 200);
    DMRFPixY_ = DMeanR.make<TH1D>("DMRFPix-Y", "DMR of FPix-Y;mean of Y-residuals;modules", 100., -200, 200);

    DMRTIB_ = DMeanR.make<TH1D>("DMRTIB", "DMR of TIB;mean of X-residuals;modules", 100., -200, 200);
    DMRTOB_ = DMeanR.make<TH1D>("DMRTOB", "DMR of TOB;mean of X-residuals;modules", 100., -200, 200);

    DMRTID_ = DMeanR.make<TH1D>("DMRTID", "DMR of TID;mean of X-residuals;modules", 100., -200, 200);
    DMRTEC_ = DMeanR.make<TH1D>("DMRTEC", "DMR of TEC;mean of X-residuals;modules", 100., -200, 200);

    TFileDirectory DMeanRSplit = fs->mkdir("SplitDMRs");

    DMRBPixXSplit_ = bookSplitDMRHistograms(DMeanRSplit, "BPix", "X", true);
    DMRBPixYSplit_ = bookSplitDMRHistograms(DMeanRSplit, "BPix", "Y", true);

    DMRFPixXSplit_ = bookSplitDMRHistograms(DMeanRSplit, "FPix", "X", false);
    DMRFPixYSplit_ = bookSplitDMRHistograms(DMeanRSplit, "FPix", "Y", false);

    DMRTIBSplit_ = bookSplitDMRHistograms(DMeanRSplit, "TIB", "X", true);
    DMRTOBSplit_ = bookSplitDMRHistograms(DMeanRSplit, "TOB", "X", true);

    // DRnRs
    TFileDirectory DRnRs = fs->mkdir("DRnRs");

    DRnRBPixX_ = DRnRs.make<TH1D>("DRnRBPix-X", "DRnR of BPix-X;rms of normalized X-residuals;modules", 100., 0., 3.);
    DRnRBPixY_ = DRnRs.make<TH1D>("DRnRBPix-Y", "DRnR of BPix-Y;rms of normalized Y-residuals;modules", 100., 0., 3.);

    DRnRFPixX_ = DRnRs.make<TH1D>("DRnRFPix-X", "DRnR of FPix-X;rms of normalized X-residuals;modules", 100., 0., 3.);
    DRnRFPixY_ = DRnRs.make<TH1D>("DRnRFPix-Y", "DRnR of FPix-Y;rms of normalized Y-residuals;modules", 100., 0., 3.);

    DRnRTIB_ = DRnRs.make<TH1D>("DRnRTIB", "DRnR of TIB;rms of normalized X-residuals;modules", 100., 0., 3.);
    DRnRTOB_ = DRnRs.make<TH1D>("DRnRTOB", "DRnR of TOB;rms of normalized Y-residuals;modules", 100., 0., 3.);

    DRnRTID_ = DRnRs.make<TH1D>("DRnRTID", "DRnR of TID;rms of normalized X-residuals;modules", 100., 0., 3.);
    DRnRTEC_ = DRnRs.make<TH1D>("DRnRTEC", "DRnR of TEC;rms of normalized Y-residuals;modules", 100., 0., 3.);

    // initialize the topology first

    SiPixelPI::PhaseInfo ph_info(phase_);
    const char *path_toTopologyXML = ph_info.pathToTopoXML();
    const TrackerTopology standaloneTopo =
        StandaloneTrackerTopology::fromTrackerParametersXMLFile(edm::FileInPath(path_toTopologyXML).fullPath());

    // initialize PixelRegionContainers
    PixelDMRS_x_ByLayer = std::make_unique<PixelRegions::PixelRegionContainers>(&standaloneTopo, ph_info.phase());
    PixelDMRS_y_ByLayer = std::make_unique<PixelRegions::PixelRegionContainers>(&standaloneTopo, ph_info.phase());

    // book PixelRegionContainers
    PixelDMRS_x_ByLayer->bookAll("Barrel Pixel DMRs", "median(x'_{pred}-x'_{hit}) [#mum]", "# modules", 100, -50, 50);
    PixelDMRS_y_ByLayer->bookAll("Barrel Pixel DMRs", "median(y'_{pred}-y'_{hit}) [#mum]", "# modules", 100, -50, 50);

    if (DEBUG) {
      auto dets = PixelRegions::attachedDets(PixelRegions::PixelId::L1, &standaloneTopo, phase_);
      for (const auto &det : dets) {
        auto myLocalTopo = PixelDMRS_x_ByLayer->getTheTopo();
        edm::LogVerbatim("DMRChecker") << myLocalTopo->print(det) << std::endl;
      }
    }

    // pixel

    for (auto &bpixid : resDetailsBPixX_) {
      DMRBPixX_->Fill(bpixid.second.runningMeanOfRes_);
      if (phase_ == SiPixelPI::phase::one) {
        pixelmap->fillBarrelBin("DMRsX", bpixid.first, bpixid.second.runningMeanOfRes_);
        fullPixelmapXDMR->fillTrackerMap(bpixid.first, bpixid.second.runningMeanOfRes_);
      }

      if (DEBUG) {
        auto myLocalTopo = PixelDMRS_x_ByLayer->getTheTopo();
        edm::LogPrint("DMRChecker") << myLocalTopo->print(bpixid.first) << std::endl;
      }

      PixelDMRS_x_ByLayer->fill(bpixid.first, bpixid.second.runningMeanOfRes_);

      // split DMR
      if (bpixid.second.rDirection > 0) {
        DMRBPixXSplit_[0]->Fill(bpixid.second.runningMeanOfRes_);
      } else {
        DMRBPixXSplit_[1]->Fill(bpixid.second.runningMeanOfRes_);
      }

      if (bpixid.second.hitCount < 2)
        DRnRBPixX_->Fill(-1);
      else
        DRnRBPixX_->Fill(sqrt(bpixid.second.runningNormVarOfRes_ / (bpixid.second.hitCount - 1)));
    }

    for (auto &bpixid : resDetailsBPixY_) {
      DMRBPixY_->Fill(bpixid.second.runningMeanOfRes_);
      if (phase_ == SiPixelPI::phase::one) {
        pixelmap->fillBarrelBin("DMRsY", bpixid.first, bpixid.second.runningMeanOfRes_);
        fullPixelmapYDMR->fillTrackerMap(bpixid.first, bpixid.second.runningMeanOfRes_);
      }

      PixelDMRS_y_ByLayer->fill(bpixid.first, bpixid.second.runningMeanOfRes_);

      // split DMR
      if (bpixid.second.rDirection > 0) {
        DMRBPixYSplit_[0]->Fill(bpixid.second.runningMeanOfRes_);
      } else {
        DMRBPixYSplit_[1]->Fill(bpixid.second.runningMeanOfRes_);
      }

      if (bpixid.second.hitCount < 2)
        DRnRBPixY_->Fill(-1);
      else
        DRnRBPixY_->Fill(sqrt(bpixid.second.runningNormVarOfRes_ / (bpixid.second.hitCount - 1)));
    }

    for (auto &fpixid : resDetailsFPixX_) {
      DMRFPixX_->Fill(fpixid.second.runningMeanOfRes_);
      if (phase_ == SiPixelPI::phase::one) {
        pixelmap->fillForwardBin("DMRsX", fpixid.first, fpixid.second.runningMeanOfRes_);
        fullPixelmapXDMR->fillTrackerMap(fpixid.first, fpixid.second.runningMeanOfRes_);
      }
      PixelDMRS_x_ByLayer->fill(fpixid.first, fpixid.second.runningMeanOfRes_);

      // split DMR
      if (fpixid.second.zDirection > 0) {
        DMRFPixXSplit_[0]->Fill(fpixid.second.runningMeanOfRes_);
      } else {
        DMRFPixXSplit_[1]->Fill(fpixid.second.runningMeanOfRes_);
      }

      if (fpixid.second.hitCount < 2)
        DRnRFPixX_->Fill(-1);
      else
        DRnRFPixX_->Fill(sqrt(fpixid.second.runningNormVarOfRes_ / (fpixid.second.hitCount - 1)));
    }

    for (auto &fpixid : resDetailsFPixY_) {
      DMRFPixY_->Fill(fpixid.second.runningMeanOfRes_);
      if (phase_ == SiPixelPI::phase::one) {
        pixelmap->fillForwardBin("DMRsY", fpixid.first, fpixid.second.runningMeanOfRes_);
        fullPixelmapXDMR->fillTrackerMap(fpixid.first, fpixid.second.runningMeanOfRes_);
      }
      PixelDMRS_y_ByLayer->fill(fpixid.first, fpixid.second.runningMeanOfRes_);

      // split DMR
      if (fpixid.second.zDirection > 0) {
        DMRFPixYSplit_[0]->Fill(fpixid.second.runningMeanOfRes_);
      } else {
        DMRFPixYSplit_[1]->Fill(fpixid.second.runningMeanOfRes_);
      }

      if (fpixid.second.hitCount < 2)
        DRnRFPixY_->Fill(-1);
      else
        DRnRFPixY_->Fill(sqrt(fpixid.second.runningNormVarOfRes_ / (fpixid.second.hitCount - 1)));
    }

    // strips

    for (auto &tibid : resDetailsTIB_) {
      DMRTIB_->Fill(tibid.second.runningMeanOfRes_);

      // split DMR
      if (tibid.second.rDirection > 0) {
        DMRTIBSplit_[0]->Fill(tibid.second.runningMeanOfRes_);
      } else {
        DMRTIBSplit_[1]->Fill(tibid.second.runningMeanOfRes_);
      }

      if (tibid.second.hitCount < 2)
        DRnRTIB_->Fill(-1);
      else
        DRnRTIB_->Fill(sqrt(tibid.second.runningNormVarOfRes_ / (tibid.second.hitCount - 1)));
    }

    for (auto &tobid : resDetailsTOB_) {
      DMRTOB_->Fill(tobid.second.runningMeanOfRes_);

      // split DMR
      if (tobid.second.rDirection > 0) {
        DMRTOBSplit_[0]->Fill(tobid.second.runningMeanOfRes_);
      } else {
        DMRTOBSplit_[1]->Fill(tobid.second.runningMeanOfRes_);
      }

      if (tobid.second.hitCount < 2)
        DRnRTOB_->Fill(-1);
      else
        DRnRTOB_->Fill(sqrt(tobid.second.runningNormVarOfRes_ / (tobid.second.hitCount - 1)));
    }

    for (auto &tidid : resDetailsTID_) {
      DMRTID_->Fill(tidid.second.runningMeanOfRes_);

      if (tidid.second.hitCount < 2)
        DRnRTID_->Fill(-1);
      else
        DRnRTID_->Fill(sqrt(tidid.second.runningNormVarOfRes_ / (tidid.second.hitCount - 1)));
    }

    for (auto &tecid : resDetailsTEC_) {
      DMRTEC_->Fill(tecid.second.runningMeanOfRes_);

      if (tecid.second.hitCount < 2)
        DRnRTEC_->Fill(-1);
      else
        DRnRTEC_->Fill(sqrt(tecid.second.runningNormVarOfRes_ / (tecid.second.hitCount - 1)));
    }

    edm::LogPrint("DMRChecker") << "n. of bpix modules " << resDetailsBPixX_.size() << std::endl;
    edm::LogPrint("DMRChecker") << "n. of fpix modules " << resDetailsFPixX_.size() << std::endl;

    if (phase_ == SiPixelPI::phase::zero) {
      pmap->save(true, 0, 0, "PixelHitMap.pdf", 600, 800);
      pmap->save(true, 0, 0, "PixelHitMap.png", 500, 750);
    }

    tmap->save(true, 0, 0, "StripHitMap.pdf");
    tmap->save(true, 0, 0, "StripHitMap.png");

    if (phase_ == SiPixelPI::phase::one) {
      gStyle->SetPalette(kRainBow);
      pixelmap->beautifyAllHistograms();

      TCanvas cBX("CanvXBarrel", "CanvXBarrel", 1200, 1000);
      pixelmap->drawBarrelMaps("DMRsX", cBX);
      cBX.SaveAs("pixelBarrelDMR_x.png");

      TCanvas cFX("CanvXForward", "CanvXForward", 1600, 1000);
      pixelmap->drawForwardMaps("DMRsX", cFX);
      cFX.SaveAs("pixelForwardDMR_x.png");

      TCanvas cBY("CanvYBarrel", "CanvYBarrel", 1200, 1000);
      pixelmap->drawBarrelMaps("DMRsY", cBY);
      cBY.SaveAs("pixelBarrelDMR_y.png");

      TCanvas cFY("CanvXForward", "CanvXForward", 1600, 1000);
      pixelmap->drawForwardMaps("DMRsY", cFY);
      cFY.SaveAs("pixelForwardDMR_y.png");

      TCanvas cFullPixelxDMR("CanvFullPixelX", "CanvFullPixelX", 3000, 2000);
      fullPixelmapXDMR->printTrackerMap(cFullPixelxDMR);
      cFullPixelxDMR.SaveAs("fullPixelDMR_x.png");

      TCanvas cFullPixelyDMR("CanvFullPixelX", "CanvFullPixelY", 3000, 2000);
      fullPixelmapXDMR->printTrackerMap(cFullPixelyDMR);
      cFullPixelyDMR.SaveAs("fullPixelDMR_y.png");
    }

    // take care now of the 1D histograms
    gStyle->SetOptStat("emr");
    PixelDMRS_x_ByLayer->beautify(2, 0);
    PixelDMRS_y_ByLayer->beautify(2, 0);

    TCanvas DMRxBarrel("DMRxBarrelCanv", "x-coordinate", 1400, 1200);
    DMRxBarrel.Divide(2, 2);
    PixelDMRS_x_ByLayer->draw(DMRxBarrel, true, "HISTS");
    adjustCanvases(DMRxBarrel, true);
    for (unsigned int c = 1; c <= 4; c++) {
      DMRxBarrel.cd(c)->Update();
    }
    PixelDMRS_x_ByLayer->stats();

    TCanvas DMRxForward("DMRxForwardCanv", "x-coordinate", 1400, 1200);
    DMRxForward.Divide(4, 3);
    PixelDMRS_x_ByLayer->draw(DMRxForward, false, "HISTS");
    adjustCanvases(DMRxForward, false);
    for (unsigned int c = 1; c <= 12; c++) {
      DMRxForward.cd(c)->Update();
    }
    PixelDMRS_x_ByLayer->stats();

    DMRxBarrel.SaveAs("DMR_x_Barrel_ByLayer.png");
    DMRxForward.SaveAs("DMR_x_Forward_ByRing.png");

    TCanvas DMRyBarrel("DMRyBarrelCanv", "y-coordinate", 1400, 1200);
    DMRyBarrel.Divide(2, 2);
    PixelDMRS_y_ByLayer->draw(DMRyBarrel, true, "HISTS");
    adjustCanvases(DMRyBarrel, true);
    for (unsigned int c = 1; c <= 4; c++) {
      DMRyBarrel.cd(c)->Update();
    }
    PixelDMRS_y_ByLayer->stats();

    TCanvas DMRyForward("DMRyForwardCanv", "y-coordinate", 1400, 1200);
    DMRyForward.Divide(4, 3);
    PixelDMRS_y_ByLayer->draw(DMRyForward, false, "HISTS");
    adjustCanvases(DMRyForward, false);
    for (unsigned int c = 1; c <= 12; c++) {
      DMRyForward.cd(c)->Update();
    }
    PixelDMRS_y_ByLayer->stats();

    DMRyBarrel.SaveAs("DMR_y_Barrel_ByLayer.png");
    DMRyForward.SaveAs("DMR_y_Forward_ByRing.png");
  }

endRun()

void DMRChecker::endRun ( edm::Run const &  , edm::EventSetup const &    )

inlineoverrideprivate

Definition at line 1138 of file DMRChecker.cc.

{}

fillByIndex()

void DMRChecker::fillByIndex ( std::map< unsigned int, TH1D *> &  h, unsigned int  index, double  x  )

inlineprivate

Definition at line 2027 of file DMRChecker.cc.

References h, WZElectronSkims53X_cff::max, SiStripPI::min, and x.

                                                                                  {
    if (h.count(index) != 0) {
      //if(TString(h[index]->GetName()).Contains("BPix"))
      //edm::LogPrint("DMRChecker")<<"fillByIndex() index: "<< index << " filling histogram: "<< h[index]->GetName() << std::endl;

      double min = h[index]->GetXaxis()->GetXmin();
      double max = h[index]->GetXaxis()->GetXmax();
      if (x < min)
        h[index]->Fill(min);
      else if (x >= max)
        h[index]->Fill(0.99999 * max);
      else
        h[index]->Fill(x);
    }
  }

fillDescriptions()

void DMRChecker::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

Definition at line 2105 of file DMRChecker.cc.

References edm::ConfigurationDescriptions::addWithDefaultLabel(), submitPVResolutionJobs::desc, and ProducerED_cfi::InputTag.

{
  edm::ParameterSetDescription desc;
  desc.setComment("Generic track analyzer to check ALCARECO sample quantities / compute fast DMRs");
  desc.add<edm::InputTag>("TkTag", edm::InputTag("generalTracks"));
  desc.add<edm::InputTag>("TriggerResultsTag", edm::InputTag("TriggerResults", "", "HLT"));
  desc.add<edm::InputTag>("BeamSpotTag", edm::InputTag("offlineBeamSpot"));
  desc.add<edm::InputTag>("VerticesTag", edm::InputTag("offlinePrimaryVertices"));
  desc.add<bool>("isCosmics", false);
  desc.add<bool>("doLatencyAnalysis", true);
  descriptions.addWithDefaultLabel(desc);
}

fillDMRs()

void DMRChecker::fillDMRs ( const running::estimatorMap &  myDetails, TH1D *  DMR, TH1D *  DRnR, std::array< TH1D *, 2 >  DMRSplit, std::unique_ptr< PixelRegions::PixelRegionContainers >  regionalDMR  )

inlineprivate

Definition at line 2073 of file DMRChecker.cc.

References mathSSE::sqrt().

                                                                              {
    for (const auto &element : myDetails) {
      // DMR
      DMR->Fill(element.second.runningMeanOfRes_);

      // DMR by layer
      if (regionalDMR.get()) {
        regionalDMR->fill(element.first, element.second.runningMeanOfRes_);
      }

      // split DMR
      if (element.second.rOrZDirection > 0) {
        DMRSplit[0]->Fill(element.second.runningMeanOfRes_);
      } else {
        DMRSplit[1]->Fill(element.second.runningMeanOfRes_);
      }

      // DRnR
      if (element.second.hitCount < 2) {
        DRnR->Fill(-1);
      } else {
        DRnR->Fill(sqrt(element.second.runningNormVarOfRes_ / (element.second.hitCount - 1)));
      }
    }
  }

index()

template<class OBJECT_TYPE >

int DMRChecker::index ( const std::vector< OBJECT_TYPE *> &  vec, const std::string &  name  )

inline

Definition at line 217 of file DMRChecker.cc.

References mergeVDriftHistosByStation::name.

                                                                        {
    for (const auto &iter : vec | boost::adaptors::indexed(0)) {
      if (iter.value() && iter.value()->GetName() == name) {
        return iter.index();
      }
    }
    edm::LogError("Alignment") << "@SUB=DMRChecker::index"
                               << " could not find " << name;
    return -1;
  }

isHit2D()

bool DMRChecker::isHit2D ( const TrackingRecHit &  hit )

inlineprivate

Definition at line 1885 of file DMRChecker.cc.

References hcalRecHitTable_cff::detId, kBPIX, kFPIX, ProjectedSiStripRecHit2D::originalHit(), SiStripDetId::stereo(), and DetId::Tracker.

                                          {
    bool countStereoHitAs2D_ = true;
    // we count SiStrip stereo modules as 2D if selected via countStereoHitAs2D_
    // (since they provide theta information)
    if (!hit.isValid() ||
        (hit.dimension() < 2 && !countStereoHitAs2D_ && !dynamic_cast<const SiStripRecHit1D *>(&hit))) {
      return false;  // real RecHit1D - but SiStripRecHit1D depends on countStereoHitAs2D_
    } else {
      const DetId detId(hit.geographicalId());
      if (detId.det() == DetId::Tracker) {
        if (detId.subdetId() == kBPIX || detId.subdetId() == kFPIX) {
          return true;  // pixel is always 2D
        } else {        // should be SiStrip now
          const SiStripDetId stripId(detId);
          if (stripId.stereo())
            return countStereoHitAs2D_;  // stereo modules
          else if (dynamic_cast<const SiStripRecHit1D *>(&hit) || dynamic_cast<const SiStripRecHit2D *>(&hit))
            return false;  // rphi modules hit
          //the following two are not used any more since ages...
          else if (dynamic_cast<const SiStripMatchedRecHit2D *>(&hit))
            return true;  // matched is 2D
          else if (dynamic_cast<const ProjectedSiStripRecHit2D *>(&hit)) {
            const ProjectedSiStripRecHit2D *pH = static_cast<const ProjectedSiStripRecHit2D *>(&hit);
            return (countStereoHitAs2D_ && this->isHit2D(pH->originalHit()));  // depends on original...
          } else {
            edm::LogError("UnknownType") << "@SUB=DMRChecker::isHit2D"
                                         << "Tracker hit not in pixel, neither SiStripRecHit[12]D nor "
                                         << "SiStripMatchedRecHit2D nor ProjectedSiStripRecHit2D.";
            return false;
          }
        }
      } else {  // not tracker??
        edm::LogWarning("DetectorMismatch") << "@SUB=DMRChecker::isHit2D"
                                            << "Hit not in tracker with 'official' dimension >=2.";
        return true;  // dimension() >= 2 so accept that...
      }
    }
    // never reached...
  }

updateOnlineMomenta()

void DMRChecker::updateOnlineMomenta ( running::estimatorMap &  myDetails, uint32_t  theID, float  the_data, float  the_pull  )

inlineprivate

Definition at line 2047 of file DMRChecker.cc.

References dumpMFGeometry_cfg::delta.

                                                                                                           {
    myDetails[theID].hitCount += 1;

    float delta = 0;
    float n_delta = 0;

    if (myDetails[theID].hitCount != 1) {
      delta = the_data - myDetails[theID].runningMeanOfRes_;
      n_delta = the_pull - myDetails[theID].runningNormMeanOfRes_;
      myDetails[theID].runningMeanOfRes_ += (delta / myDetails[theID].hitCount);
      myDetails[theID].runningNormMeanOfRes_ += (n_delta / myDetails[theID].hitCount);
    } else {
      myDetails[theID].runningMeanOfRes_ = the_data;
      myDetails[theID].runningNormMeanOfRes_ = the_pull;
    }

    float delta2 = the_data - myDetails[theID].runningMeanOfRes_;
    float n_delta2 = the_pull - myDetails[theID].runningNormMeanOfRes_;

    myDetails[theID].runningVarOfRes_ += delta * delta2;
    myDetails[theID].runningNormVarOfRes_ += n_delta * n_delta2;
  }

Member Data Documentation

barrelLayersPullsX

std::map<unsigned int, TH1D *> DMRChecker::barrelLayersPullsX

private

Definition at line 461 of file DMRChecker.cc.

barrelLayersPullsY

std::map<unsigned int, TH1D *> DMRChecker::barrelLayersPullsY

private

Definition at line 463 of file DMRChecker.cc.

barrelLayersResidualsX

std::map<unsigned int, TH1D *> DMRChecker::barrelLayersResidualsX

private

Definition at line 460 of file DMRChecker.cc.

barrelLayersResidualsY

std::map<unsigned int, TH1D *> DMRChecker::barrelLayersResidualsY

private

Definition at line 462 of file DMRChecker.cc.

BeamSpotTag_

edm::InputTag DMRChecker::BeamSpotTag_

private

Definition at line 482 of file DMRChecker.cc.

beamspotToken_

edm::EDGetTokenT<reco::BeamSpot> DMRChecker::beamspotToken_

private

Definition at line 487 of file DMRChecker.cc.

conditionsMap_

std::map<int, std::pair<int, float> > DMRChecker::conditionsMap_

private

Definition at line 491 of file DMRChecker.cc.

DMRBPixX_

TH1D* DMRChecker::DMRBPixX_

private

Definition at line 421 of file DMRChecker.cc.

DMRBPixXSplit_

std::array<TH1D *, 2> DMRChecker::DMRBPixXSplit_

private

Definition at line 449 of file DMRChecker.cc.

DMRBPixY_

TH1D* DMRChecker::DMRBPixY_

private

Definition at line 422 of file DMRChecker.cc.

DMRBPixYSplit_

std::array<TH1D *, 2> DMRChecker::DMRBPixYSplit_

private

Definition at line 450 of file DMRChecker.cc.

DMRFPixX_

TH1D* DMRChecker::DMRFPixX_

private

Definition at line 424 of file DMRChecker.cc.

DMRFPixXSplit_

std::array<TH1D *, 2> DMRChecker::DMRFPixXSplit_

private

Definition at line 452 of file DMRChecker.cc.

DMRFPixY_

TH1D* DMRChecker::DMRFPixY_

private

Definition at line 425 of file DMRChecker.cc.

DMRFPixYSplit_

std::array<TH1D *, 2> DMRChecker::DMRFPixYSplit_

private

Definition at line 453 of file DMRChecker.cc.

DMRTEC_

TH1D* DMRChecker::DMRTEC_

private

Definition at line 439 of file DMRChecker.cc.

DMRTIB_

TH1D* DMRChecker::DMRTIB_

private

Definition at line 435 of file DMRChecker.cc.

DMRTIBSplit_

std::array<TH1D *, 2> DMRChecker::DMRTIBSplit_

private

Definition at line 455 of file DMRChecker.cc.

DMRTID_

TH1D* DMRChecker::DMRTID_

private

Definition at line 438 of file DMRChecker.cc.

DMRTOB_

TH1D* DMRChecker::DMRTOB_

private

Definition at line 436 of file DMRChecker.cc.

DMRTOBSplit_

std::array<TH1D *, 2> DMRChecker::DMRTOBSplit_

private

Definition at line 456 of file DMRChecker.cc.

doLatencyAnalysis_

const bool DMRChecker::doLatencyAnalysis_

private

Definition at line 478 of file DMRChecker.cc.

DRnRBPixX_

TH1D* DMRChecker::DRnRBPixX_

private

Definition at line 427 of file DMRChecker.cc.

DRnRBPixY_

TH1D* DMRChecker::DRnRBPixY_

private

Definition at line 428 of file DMRChecker.cc.

DRnRFPixX_

TH1D* DMRChecker::DRnRFPixX_

private

Definition at line 430 of file DMRChecker.cc.

DRnRFPixY_

TH1D* DMRChecker::DRnRFPixY_

private

Definition at line 431 of file DMRChecker.cc.

DRnRTEC_

TH1D* DMRChecker::DRnRTEC_

private

Definition at line 445 of file DMRChecker.cc.

DRnRTIB_

TH1D* DMRChecker::DRnRTIB_

private

Definition at line 441 of file DMRChecker.cc.

DRnRTID_

TH1D* DMRChecker::DRnRTID_

private

Definition at line 444 of file DMRChecker.cc.

DRnRTOB_

TH1D* DMRChecker::DRnRTOB_

private

Definition at line 442 of file DMRChecker.cc.

endcapDisksPullsX

std::map<unsigned int, TH1D *> DMRChecker::endcapDisksPullsX

private

Definition at line 466 of file DMRChecker.cc.

endcapDisksPullsY

std::map<unsigned int, TH1D *> DMRChecker::endcapDisksPullsY

private

Definition at line 468 of file DMRChecker.cc.

endcapDisksResidualsX

std::map<unsigned int, TH1D *> DMRChecker::endcapDisksResidualsX

private

Definition at line 465 of file DMRChecker.cc.

endcapDisksResidualsY

std::map<unsigned int, TH1D *> DMRChecker::endcapDisksResidualsY

private

Definition at line 467 of file DMRChecker.cc.

etaMax_

float DMRChecker::etaMax_

private

Definition at line 475 of file DMRChecker.cc.

eventRatesByRun_

TH1D* DMRChecker::eventRatesByRun_

private

Definition at line 414 of file DMRChecker.cc.

evtsByTrigger_

TH1D* DMRChecker::evtsByTrigger_

private

Definition at line 405 of file DMRChecker.cc.

fieldByRun_

TH1D* DMRChecker::fieldByRun_

private

Definition at line 408 of file DMRChecker.cc.

fs

edm::Service<TFileService> DMRChecker::fs

private

Definition at line 247 of file DMRChecker.cc.

fullPixelmapXDMR

std::unique_ptr<Phase1PixelSummaryMap> DMRChecker::fullPixelmapXDMR

private

Definition at line 250 of file DMRChecker.cc.

fullPixelmapYDMR

std::unique_ptr<Phase1PixelSummaryMap> DMRChecker::fullPixelmapYDMR

private

Definition at line 251 of file DMRChecker.cc.

geomToken_

const edm::ESGetToken<TrackerGeometry, TrackerDigiGeometryRecord> DMRChecker::geomToken_

private

Definition at line 236 of file DMRChecker.cc.

hBPixResXPrime

TH1D* DMRChecker::hBPixResXPrime

private

Definition at line 275 of file DMRChecker.cc.

hBPixResXPull

TH1D* DMRChecker::hBPixResXPull

private

Definition at line 285 of file DMRChecker.cc.

hBPixResYPrime

TH1D* DMRChecker::hBPixResYPrime

private

Definition at line 280 of file DMRChecker.cc.

hBPixResYPull

TH1D* DMRChecker::hBPixResYPull

private

Definition at line 290 of file DMRChecker.cc.

hCharge

TH1D* DMRChecker::hCharge

private

Definition at line 342 of file DMRChecker.cc.

hchi2ndof

TH1D* DMRChecker::hchi2ndof

private

Definition at line 259 of file DMRChecker.cc.

hchi2ndofhp

TH1D* DMRChecker::hchi2ndofhp

private

Definition at line 339 of file DMRChecker.cc.

hchi2Probhp

TH1D* DMRChecker::hchi2Probhp

private

Definition at line 340 of file DMRChecker.cc.

hd0

TH1D* DMRChecker::hd0

private

Definition at line 364 of file DMRChecker.cc.

hd0BS

TH1D* DMRChecker::hd0BS

private

Definition at line 392 of file DMRChecker.cc.

hd0PV

TH1D* DMRChecker::hd0PV

private

Definition at line 395 of file DMRChecker.cc.

hd0PVvseta

TH2D* DMRChecker::hd0PVvseta

private

Definition at line 369 of file DMRChecker.cc.

hd0PVvsphi

TH2D* DMRChecker::hd0PVvsphi

private

Definition at line 368 of file DMRChecker.cc.

hd0PVvspt

TH2D* DMRChecker::hd0PVvspt

private

Definition at line 370 of file DMRChecker.cc.

hd0vseta

TH2D* DMRChecker::hd0vseta

private

Definition at line 373 of file DMRChecker.cc.

hd0vsphi

TH2D* DMRChecker::hd0vsphi

private

Definition at line 372 of file DMRChecker.cc.

hd0vspt

TH2D* DMRChecker::hd0vspt

private

Definition at line 374 of file DMRChecker.cc.

hDeltaEta

TH1D* DMRChecker::hDeltaEta

private

Definition at line 358 of file DMRChecker.cc.

hDeltaPhi

TH1D* DMRChecker::hDeltaPhi

private

Definition at line 357 of file DMRChecker.cc.

hDeltaR

TH1D* DMRChecker::hDeltaR

private

Definition at line 359 of file DMRChecker.cc.

hdxy

TH1D* DMRChecker::hdxy

private

Definition at line 366 of file DMRChecker.cc.

hdxyBS

TH1D* DMRChecker::hdxyBS

private

Definition at line 391 of file DMRChecker.cc.

hdxyPV

TH1D* DMRChecker::hdxyPV

private

Definition at line 394 of file DMRChecker.cc.

hdz

TH1D* DMRChecker::hdz

private

Definition at line 365 of file DMRChecker.cc.

hdzBS

TH1D* DMRChecker::hdzBS

private

Definition at line 393 of file DMRChecker.cc.

hdzPV

TH1D* DMRChecker::hdzPV

private

Definition at line 396 of file DMRChecker.cc.

hEta

TH1D* DMRChecker::hEta

private

Definition at line 345 of file DMRChecker.cc.

hEtahp

TH1D* DMRChecker::hEtahp

private

Definition at line 337 of file DMRChecker.cc.

hEtaMinus

TH1D* DMRChecker::hEtaMinus

private

Definition at line 347 of file DMRChecker.cc.

hEtaPlus

TH1D* DMRChecker::hEtaPlus

private

Definition at line 346 of file DMRChecker.cc.

hFPixResXPrime

TH1D* DMRChecker::hFPixResXPrime

private

Definition at line 276 of file DMRChecker.cc.

hFPixResXPull

TH1D* DMRChecker::hFPixResXPull

private

Definition at line 286 of file DMRChecker.cc.

hFPixResYPrime

TH1D* DMRChecker::hFPixResYPrime

private

Definition at line 281 of file DMRChecker.cc.

hFPixResYPull

TH1D* DMRChecker::hFPixResYPull

private

Definition at line 291 of file DMRChecker.cc.

hFPixZMinusResXPrime

TH1D* DMRChecker::hFPixZMinusResXPrime

private

Definition at line 278 of file DMRChecker.cc.

hFPixZMinusResXPull

TH1D* DMRChecker::hFPixZMinusResXPull

private

Definition at line 288 of file DMRChecker.cc.

hFPixZMinusResYPrime

TH1D* DMRChecker::hFPixZMinusResYPrime

private

Definition at line 283 of file DMRChecker.cc.

hFPixZMinusResYPull

TH1D* DMRChecker::hFPixZMinusResYPull

private

Definition at line 293 of file DMRChecker.cc.

hFPixZPlusResXPrime

TH1D* DMRChecker::hFPixZPlusResXPrime

private

Definition at line 277 of file DMRChecker.cc.

hFPixZPlusResXPull

TH1D* DMRChecker::hFPixZPlusResXPull

private

Definition at line 287 of file DMRChecker.cc.

hFPixZPlusResYPrime

TH1D* DMRChecker::hFPixZPlusResYPrime

private

Definition at line 282 of file DMRChecker.cc.

hFPixZPlusResYPull

TH1D* DMRChecker::hFPixZPlusResYPull

private

Definition at line 292 of file DMRChecker.cc.

hHit

TH1D* DMRChecker::hHit

private

Definition at line 272 of file DMRChecker.cc.

hHit2D

TH1D* DMRChecker::hHit2D

private

Definition at line 273 of file DMRChecker.cc.

hHitComposition

TH1D* DMRChecker::hHitComposition

private

Definition at line 383 of file DMRChecker.cc.

hHitCountVsPhiBPix

TH1D* DMRChecker::hHitCountVsPhiBPix

private

Definition at line 313 of file DMRChecker.cc.

hHitCountVsPhiFPix

TH1D* DMRChecker::hHitCountVsPhiFPix

private

Definition at line 316 of file DMRChecker.cc.

hHitCountVsPhiFPixMinus

TH1D* DMRChecker::hHitCountVsPhiFPixMinus

private

Definition at line 329 of file DMRChecker.cc.

hHitCountVsPhiFPixPlus

TH1D* DMRChecker::hHitCountVsPhiFPixPlus

private

Definition at line 326 of file DMRChecker.cc.

hHitCountVsThetaBPix

TH1D* DMRChecker::hHitCountVsThetaBPix

private

Definition at line 312 of file DMRChecker.cc.

hHitCountVsThetaFPix

TH1D* DMRChecker::hHitCountVsThetaFPix

private

Definition at line 315 of file DMRChecker.cc.

hHitCountVsThetaFPixMinus

TH1D* DMRChecker::hHitCountVsThetaFPixMinus

private

Definition at line 328 of file DMRChecker.cc.

hHitCountVsThetaFPixPlus

TH1D* DMRChecker::hHitCountVsThetaFPixPlus

private

Definition at line 325 of file DMRChecker.cc.

hHitCountVsXBPix

TH1D* DMRChecker::hHitCountVsXBPix

private

Definition at line 305 of file DMRChecker.cc.

hHitCountVsXFPix

TH1D* DMRChecker::hHitCountVsXFPix

private

Definition at line 306 of file DMRChecker.cc.

hHitCountVsXFPixMinus

TH1D* DMRChecker::hHitCountVsXFPixMinus

private

Definition at line 319 of file DMRChecker.cc.

hHitCountVsXFPixPlus

TH1D* DMRChecker::hHitCountVsXFPixPlus

private

Definition at line 318 of file DMRChecker.cc.

hHitCountVsYBPix

TH1D* DMRChecker::hHitCountVsYBPix

private

Definition at line 307 of file DMRChecker.cc.

hHitCountVsYFPix

TH1D* DMRChecker::hHitCountVsYFPix

private

Definition at line 308 of file DMRChecker.cc.

hHitCountVsYFPixMinus

TH1D* DMRChecker::hHitCountVsYFPixMinus

private

Definition at line 321 of file DMRChecker.cc.

hHitCountVsYFPixPlus

TH1D* DMRChecker::hHitCountVsYFPixPlus

private

Definition at line 320 of file DMRChecker.cc.

hHitCountVsZBPix

TH1D* DMRChecker::hHitCountVsZBPix

private

Definition at line 309 of file DMRChecker.cc.

hHitCountVsZFPix

TH1D* DMRChecker::hHitCountVsZFPix

private

Definition at line 310 of file DMRChecker.cc.

hHitCountVsZFPixMinus

TH1D* DMRChecker::hHitCountVsZFPixMinus

private

Definition at line 323 of file DMRChecker.cc.

hHitCountVsZFPixPlus

TH1D* DMRChecker::hHitCountVsZFPixPlus

private

Definition at line 322 of file DMRChecker.cc.

hHithp

TH1D* DMRChecker::hHithp

private

Definition at line 336 of file DMRChecker.cc.

hHitMinus

TH1D* DMRChecker::hHitMinus

private

Definition at line 332 of file DMRChecker.cc.

hHitPlus

TH1D* DMRChecker::hHitPlus

private

Definition at line 331 of file DMRChecker.cc.

hitsByRun_

TH1D* DMRChecker::hitsByRun_

private

Definition at line 411 of file DMRChecker.cc.

hitsinBPixByRun_

TH1D* DMRChecker::hitsinBPixByRun_

private

Definition at line 416 of file DMRChecker.cc.

hitsinFPixByRun_

TH1D* DMRChecker::hitsinFPixByRun_

private

Definition at line 417 of file DMRChecker.cc.

hltresultsToken_

edm::EDGetTokenT<edm::TriggerResults> DMRChecker::hltresultsToken_

private

Definition at line 486 of file DMRChecker.cc.

hlumi

TH1D* DMRChecker::hlumi

private

Definition at line 398 of file DMRChecker.cc.

hMinPt

TH1D* DMRChecker::hMinPt

private

Definition at line 269 of file DMRChecker.cc.

hMultCand

TH1D* DMRChecker::hMultCand

private

Definition at line 389 of file DMRChecker.cc.

hNhighPurity

TH1D* DMRChecker::hNhighPurity

private

Definition at line 264 of file DMRChecker.cc.

hnhpxb

TH1D* DMRChecker::hnhpxb

private

Definition at line 376 of file DMRChecker.cc.

hnhpxe

TH1D* DMRChecker::hnhpxe

private

Definition at line 377 of file DMRChecker.cc.

hnhTEC

TH1D* DMRChecker::hnhTEC

private

Definition at line 381 of file DMRChecker.cc.

hnhTIB

TH1D* DMRChecker::hnhTIB

private

Definition at line 378 of file DMRChecker.cc.

hnhTID

TH1D* DMRChecker::hnhTID

private

Definition at line 379 of file DMRChecker.cc.

hnhTOB

TH1D* DMRChecker::hnhTOB

private

Definition at line 380 of file DMRChecker.cc.

hNtrk

TH1D* DMRChecker::hNtrk

private

Definition at line 260 of file DMRChecker.cc.

hNtrkZoom

TH1D* DMRChecker::hNtrkZoom

private

Definition at line 261 of file DMRChecker.cc.

hP

TH1D* DMRChecker::hP

private

Definition at line 265 of file DMRChecker.cc.

hPhi

TH1D* DMRChecker::hPhi

private

Definition at line 348 of file DMRChecker.cc.

hPhiBarrel

TH1D* DMRChecker::hPhiBarrel

private

Definition at line 349 of file DMRChecker.cc.

hPhiEndcapMinus

TH1D* DMRChecker::hPhiEndcapMinus

private

Definition at line 353 of file DMRChecker.cc.

hPhiEndcapPlus

TH1D* DMRChecker::hPhiEndcapPlus

private

Definition at line 352 of file DMRChecker.cc.

hPhihp

TH1D* DMRChecker::hPhihp

private

Definition at line 338 of file DMRChecker.cc.

hPhiMinus

TH1D* DMRChecker::hPhiMinus

private

Definition at line 355 of file DMRChecker.cc.

hPhiOverlapMinus

TH1D* DMRChecker::hPhiOverlapMinus

private

Definition at line 351 of file DMRChecker.cc.

hPhiOverlapPlus

TH1D* DMRChecker::hPhiOverlapPlus

private

Definition at line 350 of file DMRChecker.cc.

hPhiPlus

TH1D* DMRChecker::hPhiPlus

private

Definition at line 354 of file DMRChecker.cc.

hPhp

TH1D* DMRChecker::hPhp

private

Definition at line 334 of file DMRChecker.cc.

hPMinus

TH1D* DMRChecker::hPMinus

private

Definition at line 267 of file DMRChecker.cc.

hPPlus

TH1D* DMRChecker::hPPlus

private

Definition at line 266 of file DMRChecker.cc.

hPt

TH1D* DMRChecker::hPt

private

Definition at line 268 of file DMRChecker.cc.

hPthp

TH1D* DMRChecker::hPthp

private

Definition at line 335 of file DMRChecker.cc.

hPtMinus

TH1D* DMRChecker::hPtMinus

private

Definition at line 271 of file DMRChecker.cc.

hPtPlus

TH1D* DMRChecker::hPtPlus

private

Definition at line 270 of file DMRChecker.cc.

hQoverP

TH1D* DMRChecker::hQoverP

private

Definition at line 343 of file DMRChecker.cc.

hQoverPZoom

TH1D* DMRChecker::hQoverPZoom

private

Definition at line 344 of file DMRChecker.cc.

hrun

TH1D* DMRChecker::hrun

private

Definition at line 397 of file DMRChecker.cc.

hTECResXPrime

TH1D* DMRChecker::hTECResXPrime

private

Definition at line 298 of file DMRChecker.cc.

hTECResXPull

TH1D* DMRChecker::hTECResXPull

private

Definition at line 303 of file DMRChecker.cc.

hTIBResXPrime

TH1D* DMRChecker::hTIBResXPrime

private

Definition at line 295 of file DMRChecker.cc.

hTIBResXPull

TH1D* DMRChecker::hTIBResXPull

private

Definition at line 300 of file DMRChecker.cc.

hTIDResXPrime

TH1D* DMRChecker::hTIDResXPrime

private

Definition at line 297 of file DMRChecker.cc.

hTIDResXPull

TH1D* DMRChecker::hTIDResXPull

private

Definition at line 302 of file DMRChecker.cc.

hTOBResXPrime

TH1D* DMRChecker::hTOBResXPrime

private

Definition at line 296 of file DMRChecker.cc.

hTOBResXPull

TH1D* DMRChecker::hTOBResXPull

private

Definition at line 301 of file DMRChecker.cc.

htrkAlgo

TH1I* DMRChecker::htrkAlgo

private

Definition at line 263 of file DMRChecker.cc.

htrkQuality

TH1I* DMRChecker::htrkQuality

private

Definition at line 262 of file DMRChecker.cc.

hvx

TH1D* DMRChecker::hvx

private

Definition at line 361 of file DMRChecker.cc.

hvy

TH1D* DMRChecker::hvy

private

Definition at line 362 of file DMRChecker.cc.

hvz

TH1D* DMRChecker::hvz

private

Definition at line 363 of file DMRChecker.cc.

ievt

int DMRChecker::ievt

private

Definition at line 470 of file DMRChecker.cc.

isCosmics_

const bool DMRChecker::isCosmics_

private

Definition at line 477 of file DMRChecker.cc.

itrks

int DMRChecker::itrks

private

Definition at line 471 of file DMRChecker.cc.

latencyToken_

edm::ESGetToken<SiStripLatency, SiStripLatencyRcd> DMRChecker::latencyToken_

private

Definition at line 241 of file DMRChecker.cc.

magFieldToken_

const edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> DMRChecker::magFieldToken_

private

Definition at line 238 of file DMRChecker.cc.

magneticField_

const MagneticField* DMRChecker::magneticField_

private

Definition at line 243 of file DMRChecker.cc.

mode

int DMRChecker::mode

private

Definition at line 472 of file DMRChecker.cc.

modeByRun_

TH1D* DMRChecker::modeByRun_

private

Definition at line 407 of file DMRChecker.cc.

phase_

SiPixelPI::phase DMRChecker::phase_

private

Definition at line 474 of file DMRChecker.cc.

PixelDMRS_x_ByLayer

std::unique_ptr<PixelRegions::PixelRegionContainers> DMRChecker::PixelDMRS_x_ByLayer

private

Definition at line 253 of file DMRChecker.cc.

PixelDMRS_y_ByLayer

std::unique_ptr<PixelRegions::PixelRegionContainers> DMRChecker::PixelDMRS_y_ByLayer

private

Definition at line 254 of file DMRChecker.cc.

pixelmap

std::unique_ptr<Phase1PixelMaps> DMRChecker::pixelmap

private

Definition at line 249 of file DMRChecker.cc.

pmap

std::unique_ptr<TrackerMap> DMRChecker::pmap

private

Definition at line 257 of file DMRChecker.cc.

pNBpixHitsVsVx

TProfile* DMRChecker::pNBpixHitsVsVx

private

Definition at line 385 of file DMRChecker.cc.

pNBpixHitsVsVy

TProfile* DMRChecker::pNBpixHitsVsVy

private

Definition at line 386 of file DMRChecker.cc.

pNBpixHitsVsVz

TProfile* DMRChecker::pNBpixHitsVsVz

private

Definition at line 387 of file DMRChecker.cc.

resDetailsBPixX_

running::estimatorMap DMRChecker::resDetailsBPixX_

private

Definition at line 499 of file DMRChecker.cc.

resDetailsBPixY_

running::estimatorMap DMRChecker::resDetailsBPixY_

private

Definition at line 500 of file DMRChecker.cc.

resDetailsFPixX_

running::estimatorMap DMRChecker::resDetailsFPixX_

private

Definition at line 501 of file DMRChecker.cc.

resDetailsFPixY_

running::estimatorMap DMRChecker::resDetailsFPixY_

private

Definition at line 502 of file DMRChecker.cc.

resDetailsTEC_

running::estimatorMap DMRChecker::resDetailsTEC_

private

Definition at line 509 of file DMRChecker.cc.

resDetailsTIB_

running::estimatorMap DMRChecker::resDetailsTIB_

private

Definition at line 506 of file DMRChecker.cc.

resDetailsTID_

running::estimatorMap DMRChecker::resDetailsTID_

private

Definition at line 508 of file DMRChecker.cc.

resDetailsTOB_

running::estimatorMap DMRChecker::resDetailsTOB_

private

Definition at line 507 of file DMRChecker.cc.

runHitsMap_

std::map<int, std::array<int, 6> > DMRChecker::runHitsMap_

private

Definition at line 493 of file DMRChecker.cc.

runInfoMap_

std::map<int, std::pair<int, int> > DMRChecker::runInfoMap_

private

Definition at line 492 of file DMRChecker.cc.

runInfoToken_

const edm::ESGetToken<RunInfo, RunInfoRcd> DMRChecker::runInfoToken_

private

Definition at line 237 of file DMRChecker.cc.

theTrackCollectionToken_

edm::EDGetTokenT<reco::TrackCollection> DMRChecker::theTrackCollectionToken_

private

Definition at line 485 of file DMRChecker.cc.

timeMap_

std::map<int, float> DMRChecker::timeMap_

private

Definition at line 495 of file DMRChecker.cc.

tksByTrigger_

TH1D* DMRChecker::tksByTrigger_

private

Definition at line 404 of file DMRChecker.cc.

TkTag_

edm::InputTag DMRChecker::TkTag_

private

Definition at line 480 of file DMRChecker.cc.

tmap

std::unique_ptr<TrackerMap> DMRChecker::tmap

private

Definition at line 256 of file DMRChecker.cc.

topoToken_

const edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> DMRChecker::topoToken_

private

Definition at line 239 of file DMRChecker.cc.

trackerGeometry_

const TrackerGeometry* DMRChecker::trackerGeometry_

private

Definition at line 244 of file DMRChecker.cc.

trackerTopology_

const TrackerTopology* DMRChecker::trackerTopology_

private

Definition at line 245 of file DMRChecker.cc.

trackRatesByRun_

TH1D* DMRChecker::trackRatesByRun_

private

Definition at line 413 of file DMRChecker.cc.

tracksByRun_

TH1D* DMRChecker::tracksByRun_

private

Definition at line 410 of file DMRChecker.cc.

triggerMap_

std::map<std::string, std::pair<int, int> > DMRChecker::triggerMap_

private

Definition at line 490 of file DMRChecker.cc.

TriggerResultsTag_

edm::InputTag DMRChecker::TriggerResultsTag_

private

Definition at line 481 of file DMRChecker.cc.

vertexToken_

edm::EDGetTokenT<reco::VertexCollection> DMRChecker::vertexToken_

private

Definition at line 488 of file DMRChecker.cc.

VerticesTag_

edm::InputTag DMRChecker::VerticesTag_

private

Definition at line 483 of file DMRChecker.cc.

vTrack2DHistos_

std::vector<TH1 *> DMRChecker::vTrack2DHistos_

private

Definition at line 402 of file DMRChecker.cc.

vTrackHistos_

std::vector<TH1 *> DMRChecker::vTrackHistos_

private

Definition at line 400 of file DMRChecker.cc.

vTrackProfiles_

std::vector<TH1 *> DMRChecker::vTrackProfiles_

private

Definition at line 401 of file DMRChecker.cc.