#include <Alignment/Validator/src/TrackerOfflineValidation.cc>

Inheritance diagram for TrackerOfflineValidation:

Classes
struct	DirectoryWrapper

struct	ModuleHistos

struct	SummaryContainer

Public Types
typedef dqm::legacy::DQMStore	DQMStore

enum	HistogramType { XResidual, NormXResidual, YResidual, XprimeResidual, NormXprimeResidual, YprimeResidual, NormYprimeResidual, XResidualProfile, YResidualProfile }

Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

	~TrackerOfflineValidation () override

Public Member Functions inherited from edm::one::EDAnalyzer< 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 &descriptions)

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	analyze (const edm::Event &, const edm::EventSetup &) override

void	bookDirHists (DirectoryWrapper &tfd, const Alignable &ali, const TrackerTopology *tTopo)

void	bookGlobalHists (DirectoryWrapper &tfd)

void	bookHists (DirectoryWrapper &tfd, const Alignable &ali, const TrackerTopology *tTopo, align::StructureType type, int i)

TrackerOfflineValidation::SummaryContainer	bookSummaryHists (DirectoryWrapper &tfd, const Alignable &ali, align::StructureType type, int i)

TH1 *	bookTH1F (bool isTransient, DirectoryWrapper &tfd, const char histName, const char histTitle, int nBinsX, double lowX, double highX)

TProfile *	bookTProfile (bool isTransient, DirectoryWrapper &tfd, const char histName, const char histTitle, int nBinsX, double lowX, double highX)

TProfile *	bookTProfile (bool isTransient, DirectoryWrapper &tfd, const char histName, const char histTitle, int nBinsX, double lowX, double highX, double lowY, double highY)

virtual void	checkBookHists (const edm::EventSetup &setup)

void	collateSummaryHists ()

void	endJob () override

void	fillTree (TTree &tree, TkOffTreeVariables &treeMem, const std::map< int, TrackerOfflineValidation::ModuleHistos > &moduleHist_)

std::pair< float, float >	fitResiduals (TH1 *hist) const

float	Fwhm (const TH1 *hist) const

void	getBinning (uint32_t subDetId, TrackerOfflineValidation::HistogramType residualtype, int &nBinsX, double &lowerBoundX, double &upperBoundX)

ModuleHistos &	getHistStructFromMap (const DetId &detid)

template<class OBJECT_TYPE >
int	GetIndex (const std::vector< OBJECT_TYPE *> &vec, const TString &name)

float	getMedian (const TH1 *hist) const

bool	isBarrel (uint32_t subDetId)

bool	isDetOrDetUnit (align::StructureType type)

bool	isEndCap (uint32_t subDetId)

bool	isPixel (uint32_t subDetId)

void	prepareSummaryHists (DirectoryWrapper &tfd, const Alignable &ali, std::vector< TrackerOfflineValidation::SummaryContainer > &vLevelProfiles)

void	setSummaryBin (int bin, TH1 targetHist, TH1 sourceHist)

void	setUpTreeMembers (const std::map< int, TrackerOfflineValidation::ModuleHistos > &moduleHist_, const TrackerGeometry &tkgeom, const TrackerTopology *tTopo)

void	summarizeBinInContainer (int bin, SummaryContainer &targetContainer, SummaryContainer &sourceContainer)

void	summarizeBinInContainer (int bin, uint32_t subDetId, SummaryContainer &targetContainer, ModuleHistos &sourceContainer)

Private Attributes
std::unique_ptr< AlignableTracker >	alignableTracker_

TrackerValidationVariables	avalidator_

const TrackerGeometry *	bareTkGeomPtr_

const int	chargeCut_

const int	compressionSettings_

const bool	dqmMode_

const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	geomToken_

const bool	lCoorHistOn_

const unsigned long long	maxTracks_

const std::string	moduleDirectory_

const bool	moduleLevelHistsTransient_

const bool	moduleLevelProfiles_

std::map< int, TrackerOfflineValidation::ModuleHistos >	mPxbResiduals_

std::map< int, TrackerOfflineValidation::ModuleHistos >	mPxeResiduals_

std::map< int, TrackerOfflineValidation::ModuleHistos >	mTecResiduals_

std::map< int, TrackerOfflineValidation::ModuleHistos >	mTibResiduals_

std::map< int, TrackerOfflineValidation::ModuleHistos >	mTidResiduals_

std::map< int, TrackerOfflineValidation::ModuleHistos >	mTobResiduals_

std::map< int, TkOffTreeVariables >	mTreeMembers_

unsigned long long	nTracks_

const edm::ParameterSet	parSet_

const bool	stripYResiduals_

std::vector< std::pair< TH1 , TH1 > >	sumHistStructure_

std::vector< std::tuple< int, TH1 , TH1 > >	summaryBins_

edm::ESHandle< TrackerGeometry >	tkGeom_

std::vector< TH1 * >	toFit_

const edm::ESGetToken< TrackerTopology, TrackerTopologyRcd >	topoToken_

const bool	useFit_

const bool	useFwhm_

const bool	useOverflowForRMS_

std::vector< TH1 * >	vDeleteObjects_

std::vector< TH1 * >	vTrack2DHistos_

std::vector< TH1 * >	vTrackHistos_

std::vector< TH1 * >	vTrackProfiles_

Additional Inherited Members
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

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

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

Definition at line 77 of file TrackerOfflineValidation.cc.

Member Typedef Documentation

◆ DQMStore

typedef dqm::legacy::DQMStore TrackerOfflineValidation::DQMStore

Definition at line 79 of file TrackerOfflineValidation.cc.

Member Enumeration Documentation

◆ HistogramType

enum TrackerOfflineValidation::HistogramType

Enumerator
XResidual
NormXResidual
YResidual
XprimeResidual
NormXprimeResidual
YprimeResidual
NormYprimeResidual
XResidualProfile
YResidualProfile

Definition at line 84 of file TrackerOfflineValidation.cc.

                      {
     XResidual,
     NormXResidual,
     YResidual, /*NormYResidual, */
     XprimeResidual,
     NormXprimeResidual,
     YprimeResidual,
     NormYprimeResidual,
     XResidualProfile,
     YResidualProfile
   };

Constructor & Destructor Documentation

◆ TrackerOfflineValidation()

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

explicit

Definition at line 474 of file TrackerOfflineValidation.cc.

References TFileService::kSharedResource.

     : geomToken_(esConsumes()),
       topoToken_(esConsumes()),
       parSet_(iConfig),
       bareTkGeomPtr_(nullptr),
       compressionSettings_(parSet_.getUntrackedParameter<int>("compressionSettings", -1)),
       lCoorHistOn_(parSet_.getParameter<bool>("localCoorHistosOn")),
       moduleLevelHistsTransient_(parSet_.getParameter<bool>("moduleLevelHistsTransient")),
       moduleLevelProfiles_(parSet_.getParameter<bool>("moduleLevelProfiles")),
       stripYResiduals_(parSet_.getParameter<bool>("stripYResiduals")),
       useFwhm_(parSet_.getParameter<bool>("useFwhm")),
       useFit_(parSet_.getParameter<bool>("useFit")),
       useOverflowForRMS_(parSet_.getParameter<bool>("useOverflowForRMS")),
       dqmMode_(parSet_.getParameter<bool>("useInDqmMode")),
       moduleDirectory_(parSet_.getParameter<std::string>("moduleDirectoryInOutput")),
       chargeCut_(parSet_.getParameter<int>("chargeCut")),
       nTracks_(0),
       maxTracks_(parSet_.getParameter<unsigned long long>("maxTracks")),
       avalidator_(iConfig, consumesCollector()) {
   usesResource(TFileService::kSharedResource);
 }

◆ ~TrackerOfflineValidation()

TrackerOfflineValidation::~TrackerOfflineValidation ( )

override

Definition at line 541 of file TrackerOfflineValidation.cc.

References ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, and vDeleteObjects_.

                                                     {
   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)
   for (std::vector<TH1*>::const_iterator it = vDeleteObjects_.begin(), itEnd = vDeleteObjects_.end(); it != itEnd; ++it)
     delete *it;
 }

Member Function Documentation

◆ analyze()

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

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 1164 of file TrackerOfflineValidation.cc.

                                                                                           {
   if (maxTracks_ > 0 && nTracks_ >= maxTracks_)
     return;  //don't do anything after hitting the max number of tracks
              //(could just rely on break below, but this way saves fillTrackQuantities)
 
   if (useOverflowForRMS_)
     TH1::StatOverflows(kTRUE);
   this->checkBookHists(iSetup);  // check whether hists are booked and do so if not yet done
 
   std::vector<TrackerValidationVariables::AVTrackStruct> vTrackstruct;
   avalidator_.fillTrackQuantities(iEvent, iSetup, vTrackstruct);
 
   for (std::vector<TrackerValidationVariables::AVTrackStruct>::const_iterator itT = vTrackstruct.begin();
        itT != vTrackstruct.end();
        ++itT) {
     if (itT->charge * chargeCut_ < 0)
       continue;
 
     if (maxTracks_ > 0 && nTracks_++ >= maxTracks_)
       break;  //exit the loop after hitting the max number of tracks
     // Fill 1D track histos
     static const int etaindex = this->GetIndex(vTrackHistos_, "h_tracketa");
     vTrackHistos_[etaindex]->Fill(itT->eta);
     static const int phiindex = this->GetIndex(vTrackHistos_, "h_trackphi");
     vTrackHistos_[phiindex]->Fill(itT->phi);
     static const int numOfValidHitsindex = this->GetIndex(vTrackHistos_, "h_trackNumberOfValidHits");
     vTrackHistos_[numOfValidHitsindex]->Fill(itT->numberOfValidHits);
     static const int numOfLostHitsindex = this->GetIndex(vTrackHistos_, "h_trackNumberOfLostHits");
     vTrackHistos_[numOfLostHitsindex]->Fill(itT->numberOfLostHits);
     static const int kappaindex = this->GetIndex(vTrackHistos_, "h_curvature");
     vTrackHistos_[kappaindex]->Fill(itT->kappa);
     static const int kappaposindex = this->GetIndex(vTrackHistos_, "h_curvature_pos");
     if (itT->charge > 0)
       vTrackHistos_[kappaposindex]->Fill(fabs(itT->kappa));
     static const int kappanegindex = this->GetIndex(vTrackHistos_, "h_curvature_neg");
     if (itT->charge < 0)
       vTrackHistos_[kappanegindex]->Fill(fabs(itT->kappa));
     static const int normchi2index = this->GetIndex(vTrackHistos_, "h_normchi2");
     vTrackHistos_[normchi2index]->Fill(itT->normchi2);
     static const int chi2index = this->GetIndex(vTrackHistos_, "h_chi2");
     vTrackHistos_[chi2index]->Fill(itT->chi2);
     static const int chi2Probindex = this->GetIndex(vTrackHistos_, "h_chi2Prob");
     vTrackHistos_[chi2Probindex]->Fill(itT->chi2Prob);
     static const int ptindex = this->GetIndex(vTrackHistos_, "h_pt");
     vTrackHistos_[ptindex]->Fill(itT->pt);
     if (itT->ptError != 0.) {
       static const int ptResolutionindex = this->GetIndex(vTrackHistos_, "h_ptResolution");
       vTrackHistos_[ptResolutionindex]->Fill(itT->ptError / itT->pt);
     }
     // Fill track profiles
     static const int d0phiindex = this->GetIndex(vTrackProfiles_, "p_d0_vs_phi");
     vTrackProfiles_[d0phiindex]->Fill(itT->phi, itT->d0);
     static const int dzphiindex = this->GetIndex(vTrackProfiles_, "p_dz_vs_phi");
     vTrackProfiles_[dzphiindex]->Fill(itT->phi, itT->dz);
     static const int d0etaindex = this->GetIndex(vTrackProfiles_, "p_d0_vs_eta");
     vTrackProfiles_[d0etaindex]->Fill(itT->eta, itT->d0);
     static const int dzetaindex = this->GetIndex(vTrackProfiles_, "p_dz_vs_eta");
     vTrackProfiles_[dzetaindex]->Fill(itT->eta, itT->dz);
     static const int chiphiindex = this->GetIndex(vTrackProfiles_, "p_chi2_vs_phi");
     vTrackProfiles_[chiphiindex]->Fill(itT->phi, itT->chi2);
     static const int chiProbphiindex = this->GetIndex(vTrackProfiles_, "p_chi2Prob_vs_phi");
     vTrackProfiles_[chiProbphiindex]->Fill(itT->phi, itT->chi2Prob);
     static const int chiProbabsd0index = this->GetIndex(vTrackProfiles_, "p_chi2Prob_vs_d0");
     vTrackProfiles_[chiProbabsd0index]->Fill(fabs(itT->d0), itT->chi2Prob);
     static const int normchiphiindex = this->GetIndex(vTrackProfiles_, "p_normchi2_vs_phi");
     vTrackProfiles_[normchiphiindex]->Fill(itT->phi, itT->normchi2);
     static const int chietaindex = this->GetIndex(vTrackProfiles_, "p_chi2_vs_eta");
     vTrackProfiles_[chietaindex]->Fill(itT->eta, itT->chi2);
     static const int normchiptindex = this->GetIndex(vTrackProfiles_, "p_normchi2_vs_pt");
     vTrackProfiles_[normchiptindex]->Fill(itT->pt, itT->normchi2);
     static const int normchipindex = this->GetIndex(vTrackProfiles_, "p_normchi2_vs_p");
     vTrackProfiles_[normchipindex]->Fill(itT->p, itT->normchi2);
     static const int chiProbetaindex = this->GetIndex(vTrackProfiles_, "p_chi2Prob_vs_eta");
     vTrackProfiles_[chiProbetaindex]->Fill(itT->eta, itT->chi2Prob);
     static const int normchietaindex = this->GetIndex(vTrackProfiles_, "p_normchi2_vs_eta");
     vTrackProfiles_[normchietaindex]->Fill(itT->eta, itT->normchi2);
     static const int kappaphiindex = this->GetIndex(vTrackProfiles_, "p_kappa_vs_phi");
     vTrackProfiles_[kappaphiindex]->Fill(itT->phi, itT->kappa);
     static const int kappaetaindex = this->GetIndex(vTrackProfiles_, "p_kappa_vs_eta");
     vTrackProfiles_[kappaetaindex]->Fill(itT->eta, itT->kappa);
     static const int ptResphiindex = this->GetIndex(vTrackProfiles_, "p_ptResolution_vs_phi");
     vTrackProfiles_[ptResphiindex]->Fill(itT->phi, itT->ptError / itT->pt);
     static const int ptResetaindex = this->GetIndex(vTrackProfiles_, "p_ptResolution_vs_eta");
     vTrackProfiles_[ptResetaindex]->Fill(itT->eta, itT->ptError / itT->pt);
 
     // Fill 2D track histos
     static const int d0phiindex_2d = this->GetIndex(vTrack2DHistos_, "h2_d0_vs_phi");
     vTrack2DHistos_[d0phiindex_2d]->Fill(itT->phi, itT->d0);
     static const int dzphiindex_2d = this->GetIndex(vTrack2DHistos_, "h2_dz_vs_phi");
     vTrack2DHistos_[dzphiindex_2d]->Fill(itT->phi, itT->dz);
     static const int d0etaindex_2d = this->GetIndex(vTrack2DHistos_, "h2_d0_vs_eta");
     vTrack2DHistos_[d0etaindex_2d]->Fill(itT->eta, itT->d0);
     static const int dzetaindex_2d = this->GetIndex(vTrack2DHistos_, "h2_dz_vs_eta");
     vTrack2DHistos_[dzetaindex_2d]->Fill(itT->eta, itT->dz);
     static const int chiphiindex_2d = this->GetIndex(vTrack2DHistos_, "h2_chi2_vs_phi");
     vTrack2DHistos_[chiphiindex_2d]->Fill(itT->phi, itT->chi2);
     static const int chiProbphiindex_2d = this->GetIndex(vTrack2DHistos_, "h2_chi2Prob_vs_phi");
     vTrack2DHistos_[chiProbphiindex_2d]->Fill(itT->phi, itT->chi2Prob);
     static const int chiProbabsd0index_2d = this->GetIndex(vTrack2DHistos_, "h2_chi2Prob_vs_d0");
     vTrack2DHistos_[chiProbabsd0index_2d]->Fill(fabs(itT->d0), itT->chi2Prob);
     static const int normchiphiindex_2d = this->GetIndex(vTrack2DHistos_, "h2_normchi2_vs_phi");
     vTrack2DHistos_[normchiphiindex_2d]->Fill(itT->phi, itT->normchi2);
     static const int chietaindex_2d = this->GetIndex(vTrack2DHistos_, "h2_chi2_vs_eta");
     vTrack2DHistos_[chietaindex_2d]->Fill(itT->eta, itT->chi2);
     static const int chiProbetaindex_2d = this->GetIndex(vTrack2DHistos_, "h2_chi2Prob_vs_eta");
     vTrack2DHistos_[chiProbetaindex_2d]->Fill(itT->eta, itT->chi2Prob);
     static const int normchietaindex_2d = this->GetIndex(vTrack2DHistos_, "h2_normchi2_vs_eta");
     vTrack2DHistos_[normchietaindex_2d]->Fill(itT->eta, itT->normchi2);
     static const int kappaphiindex_2d = this->GetIndex(vTrack2DHistos_, "h2_kappa_vs_phi");
     vTrack2DHistos_[kappaphiindex_2d]->Fill(itT->phi, itT->kappa);
     static const int kappaetaindex_2d = this->GetIndex(vTrack2DHistos_, "h2_kappa_vs_eta");
     vTrack2DHistos_[kappaetaindex_2d]->Fill(itT->eta, itT->kappa);
     static const int normchi2kappa_2d = this->GetIndex(vTrack2DHistos_, "h2_normchi2_vs_kappa");
     vTrack2DHistos_[normchi2kappa_2d]->Fill(itT->normchi2, itT->kappa);
 
     // hit quantities: residuals, normalized residuals
     for (std::vector<TrackerValidationVariables::AVHitStruct>::const_iterator itH = itT->hits.begin();
          itH != itT->hits.end();
          ++itH) {
       DetId detid(itH->rawDetId);
       ModuleHistos& histStruct = this->getHistStructFromMap(detid);
 
       // fill histos in local coordinates if set in cf
       if (lCoorHistOn_) {
         histStruct.ResHisto->Fill(itH->resX);
         if (itH->resErrX != 0)
           histStruct.NormResHisto->Fill(itH->resX / itH->resErrX);
         if (this->isPixel(detid.subdetId()) || stripYResiduals_) {
           histStruct.ResYHisto->Fill(itH->resY);
           // here add un-primed normalised y-residuals if wanted
         }
       }
       if (itH->resXprime != -999.) {
         histStruct.ResXprimeHisto->Fill(itH->resXprime);
 
         /******************************* Fill 2-D histo ResX vs momenta *****************************/
         if (detid.subdetId() == PixelSubdetector::PixelBarrel) {
           static const int resXvsPindex_2d = this->GetIndex(vTrack2DHistos_, "p_vs_resXprime_pixB");
           vTrack2DHistos_[resXvsPindex_2d]->Fill(itT->p, itH->resXprime);
         }
         if (detid.subdetId() == PixelSubdetector::PixelEndcap) {
           static const int resXvsPindex_2d = this->GetIndex(vTrack2DHistos_, "p_vs_resXprime_pixE");
           vTrack2DHistos_[resXvsPindex_2d]->Fill(itT->p, itH->resXprime);
         }
         if (detid.subdetId() == StripSubdetector::TIB) {
           static const int resXvsPindex_2d = this->GetIndex(vTrack2DHistos_, "p_vs_resXprime_TIB");
           vTrack2DHistos_[resXvsPindex_2d]->Fill(itT->p, itH->resXprime);
         }
         if (detid.subdetId() == StripSubdetector::TID) {
           static const int resXvsPindex_2d = this->GetIndex(vTrack2DHistos_, "p_vs_resXprime_TID");
           vTrack2DHistos_[resXvsPindex_2d]->Fill(itT->p, itH->resXprime);
         }
         if (detid.subdetId() == StripSubdetector::TOB) {
           static const int resXvsPindex_2d = this->GetIndex(vTrack2DHistos_, "p_vs_resXprime_TOB");
           vTrack2DHistos_[resXvsPindex_2d]->Fill(itT->p, itH->resXprime);
         }
         if (detid.subdetId() == StripSubdetector::TEC) {
           static const int resXvsPindex_2d = this->GetIndex(vTrack2DHistos_, "p_vs_resXprime_TEC");
           vTrack2DHistos_[resXvsPindex_2d]->Fill(itT->p, itH->resXprime);
         }
         /******************************************/
 
         if (moduleLevelProfiles_ && itH->inside) {
           float tgalpha = tan(itH->localAlpha);
           if (fabs(tgalpha) != 0) {
             histStruct.LocalX->Fill(itH->localXnorm, tgalpha * tgalpha);
             histStruct.LocalY->Fill(itH->localYnorm, tgalpha * tgalpha);
             /*           if (this->isEndCap(detid.subdetId()) && !this->isPixel(detid.subdetId())) {
              if((itH->resX)*(itH->resXprime)>0){
             histStruct.ResXvsXProfile->Fill(itH->localXnorm, itH->resXatTrkY/tgalpha, tgalpha*tgalpha);
             histStruct.ResXvsYProfile->Fill(itH->localYnorm, itH->resXatTrkY/tgalpha, tgalpha*tgalpha);
              } else {
             histStruct.ResXvsXProfile->Fill(itH->localXnorm, (-1)*itH->resXatTrkY/tgalpha, tgalpha*tgalpha);
             histStruct.ResXvsYProfile->Fill(itH->localYnorm, (-1)*itH->resXatTrkY/tgalpha, tgalpha*tgalpha);
                }
 
           }else {  
 */
             histStruct.ResXvsXProfile->Fill(itH->localXnorm, itH->resXatTrkY / tgalpha, tgalpha * tgalpha);
             histStruct.ResXvsYProfile->Fill(itH->localYnorm, itH->resXatTrkY / tgalpha, tgalpha * tgalpha);
 
             //          }
           }
         }
 
         if (itH->resXprimeErr != 0 && itH->resXprimeErr != -999) {
           histStruct.NormResXprimeHisto->Fill(itH->resXprime / itH->resXprimeErr);
         }
       }
 
       if (itH->resYprime != -999.) {
         if (this->isPixel(detid.subdetId()) || stripYResiduals_) {
           histStruct.ResYprimeHisto->Fill(itH->resYprime);
 
           /******************************* Fill 2-D histo ResY vs momenta *****************************/
           if (detid.subdetId() == PixelSubdetector::PixelBarrel) {
             static const int resYvsPindex_2d = this->GetIndex(vTrack2DHistos_, "p_vs_resYprime_pixB");
             vTrack2DHistos_[resYvsPindex_2d]->Fill(itT->p, itH->resYprime);
           }
           if (detid.subdetId() == PixelSubdetector::PixelEndcap) {
             static const int resYvsPindex_2d = this->GetIndex(vTrack2DHistos_, "p_vs_resYprime_pixE");
             vTrack2DHistos_[resYvsPindex_2d]->Fill(itT->p, itH->resYprime);
           }
           /******************************************/
 
           if (moduleLevelProfiles_ && itH->inside) {
             float tgbeta = tan(itH->localBeta);
             if (fabs(tgbeta) != 0) {
               /*           if (this->isEndCap(detid.subdetId()) && !this->isPixel(detid.subdetId())) {
             
             if((itH->resY)*(itH->resYprime)>0){
             histStruct.ResYvsXProfile->Fill(itH->localXnorm, itH->resYprime/tgbeta, tgbeta*tgbeta);
             histStruct.ResYvsYProfile->Fill(itH->localYnorm, itH->resYprime/tgbeta, tgbeta*tgbeta);
              } else {
             histStruct.ResYvsXProfile->Fill(itH->localXnorm, (-1)*itH->resYprime/tgbeta, tgbeta*tgbeta);
             histStruct.ResYvsYProfile->Fill(itH->localYnorm, (-1)*itH->resYprime/tgbeta, tgbeta*tgbeta);
                }
 
           }else {  
 */
               histStruct.ResYvsXProfile->Fill(itH->localXnorm, itH->resY / tgbeta, tgbeta * tgbeta);
               histStruct.ResYvsYProfile->Fill(itH->localYnorm, itH->resY / tgbeta, tgbeta * tgbeta);
               //              }
             }
           }
 
           if (itH->resYprimeErr != 0 && itH->resYprimeErr != -999.) {
             histStruct.NormResYprimeHisto->Fill(itH->resYprime / itH->resYprimeErr);
           }
         }
       }
 
     }  // finish loop over hit quantities
   }    // finish loop over track quantities
 
   if (useOverflowForRMS_)
     TH1::StatOverflows(kFALSE);
 }

◆ bookDirHists()

void TrackerOfflineValidation::bookDirHists	(	DirectoryWrapper &	tfd,
		const Alignable &	ali,
		const TrackerTopology *	tTopo
	)

private

Definition at line 748 of file TrackerOfflineValidation.cc.

References Alignable::alignableObjectId(), alignableTracker_, bookHists(), makeMuonMisalignmentScenario::components, Alignable::components(), BTVHLTOfflineSource_cfi::dirname, dqmMode_, f, mps_fire::i, isDetOrDetUnit(), LogDebug, moduleDirectory_, findQualityFiles::size, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by checkBookHists().

                                                                                                                      {
   const auto& alivec = ali.components();
   for (int i = 0, iEnd = ali.components().size(); i < iEnd; ++i) {
     std::string structurename = alignableTracker_->objectIdProvider().idToString((alivec)[i]->alignableObjectId());
     LogDebug("TrackerOfflineValidation") << "StructureName = " << structurename;
     std::stringstream dirname;
     dirname << structurename;
     // add no suffix counter to Strip and Pixel, just aesthetics
     if (structurename != "Strip" && structurename != "Pixel")
       dirname << "_" << i + 1;
 
     if (structurename.find("Endcap", 0) != std::string::npos) {
       DirectoryWrapper f(tfd, dirname.str(), moduleDirectory_, dqmMode_);
       bookHists(f, *(alivec)[i], tTopo, ali.alignableObjectId(), i);
       bookDirHists(f, *(alivec)[i], tTopo);
     } else if (!(this->isDetOrDetUnit((alivec)[i]->alignableObjectId())) || alivec[i]->components().size() > 1) {
       DirectoryWrapper f(tfd, dirname.str(), moduleDirectory_, dqmMode_);
       bookHists(tfd, *(alivec)[i], tTopo, ali.alignableObjectId(), i);
       bookDirHists(f, *(alivec)[i], tTopo);
     } else {
       bookHists(tfd, *(alivec)[i], tTopo, ali.alignableObjectId(), i);
     }
   }
 }

◆ bookGlobalHists()

void TrackerOfflineValidation::bookGlobalHists ( DirectoryWrapper & tfd )

private

Definition at line 597 of file TrackerOfflineValidation.cc.

References TrackerOfflineValidation::DirectoryWrapper::make(), vTrack2DHistos_, vTrackHistos_, vTrackProfiles_, and multiplicitycorr_cfi::xBins.

Referenced by checkBookHists().

                                                                     {
   vTrackHistos_.push_back(tfd.make<TH1F>("h_tracketa", "Track #eta;#eta_{Track};Number of Tracks", 90, -3., 3.));
   vTrackHistos_.push_back(tfd.make<TH1F>("h_trackphi", "Track #phi;#phi_{Track};Number of Tracks", 90, -3.15, 3.15));
   vTrackHistos_.push_back(tfd.make<TH1F>(
       "h_trackNumberOfValidHits", "Track # of valid hits;# of valid hits _{Track};Number of Tracks", 40, 0., 40.));
   vTrackHistos_.push_back(tfd.make<TH1F>(
       "h_trackNumberOfLostHits", "Track # of lost hits;# of lost hits _{Track};Number of Tracks", 10, 0., 10.));
   vTrackHistos_.push_back(
       tfd.make<TH1F>("h_curvature", "Curvature #kappa;#kappa_{Track};Number of Tracks", 100, -.05, .05));
   vTrackHistos_.push_back(tfd.make<TH1F>(
       "h_curvature_pos", "Curvature |#kappa| Positive Tracks;|#kappa_{pos Track}|;Number of Tracks", 100, .0, .05));
   vTrackHistos_.push_back(tfd.make<TH1F>(
       "h_curvature_neg", "Curvature |#kappa| Negative Tracks;|#kappa_{neg Track}|;Number of Tracks", 100, .0, .05));
   vTrackHistos_.push_back(
       tfd.make<TH1F>("h_diff_curvature",
                      "Curvature |#kappa| Tracks Difference;|#kappa_{Track}|;# Pos Tracks - # Neg Tracks",
                      100,
                      .0,
                      .05));
   vTrackHistos_.push_back(tfd.make<TH1F>("h_chi2", "#chi^{2};#chi^{2}_{Track};Number of Tracks", 500, -0.01, 500.));
   vTrackHistos_.push_back(
       tfd.make<TH1F>("h_chi2Prob", "#chi^{2} probability;#chi^{2}prob_{Track};Number of Tracks", 100, 0.0, 1.));
   vTrackHistos_.push_back(
       tfd.make<TH1F>("h_normchi2", "#chi^{2}/ndof;#chi^{2}/ndof;Number of Tracks", 100, -0.01, 10.));
   vTrackHistos_.push_back(tfd.make<TH1F>("h_pt", "p_{T}^{track};p_{T}^{track} [GeV];Number of Tracks", 250, 0., 250));
   vTrackHistos_.push_back(tfd.make<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(tfd.make<TProfile>(
       "p_d0_vs_phi", "Transverse Impact Parameter vs. #phi;#phi_{Track};#LT d_{0} #GT [cm]", 100, -3.15, 3.15));
   vTrackProfiles_.push_back(tfd.make<TProfile>(
       "p_dz_vs_phi", "Longitudinal Impact Parameter vs. #phi;#phi_{Track};#LT d_{z} #GT [cm]", 100, -3.15, 3.15));
   vTrackProfiles_.push_back(tfd.make<TProfile>(
       "p_d0_vs_eta", "Transverse Impact Parameter vs. #eta;#eta_{Track};#LT d_{0} #GT [cm]", 100, -3.15, 3.15));
   vTrackProfiles_.push_back(tfd.make<TProfile>(
       "p_dz_vs_eta", "Longitudinal Impact Parameter vs. #eta;#eta_{Track};#LT d_{z} #GT [cm]", 100, -3.15, 3.15));
   vTrackProfiles_.push_back(
       tfd.make<TProfile>("p_chi2_vs_phi", "#chi^{2} vs. #phi;#phi_{Track};#LT #chi^{2} #GT", 100, -3.15, 3.15));
   vTrackProfiles_.push_back(tfd.make<TProfile>(
       "p_chi2Prob_vs_phi", "#chi^{2} probablility vs. #phi;#phi_{Track};#LT #chi^{2} probability#GT", 100, -3.15, 3.15));
   vTrackProfiles_.push_back(tfd.make<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(tfd.make<TProfile>(
       "p_normchi2_vs_phi", "#chi^{2}/ndof vs. #phi;#phi_{Track};#LT #chi^{2}/ndof #GT", 100, -3.15, 3.15));
   vTrackProfiles_.push_back(
       tfd.make<TProfile>("p_chi2_vs_eta", "#chi^{2} vs. #eta;#eta_{Track};#LT #chi^{2} #GT", 100, -3.15, 3.15));
   //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.};
   vTrackProfiles_.push_back(tfd.make<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(
       tfd.make<TProfile>("p_normchi2_vs_p", "#chi^{2}/ndof vs. p_{Track};p_{Track};#LT #chi^{2}/ndof #GT", 18, xBins));
   vTrackProfiles_.push_back(tfd.make<TProfile>(
       "p_chi2Prob_vs_eta", "#chi^{2} probability vs. #eta;#eta_{Track};#LT #chi^{2} probability #GT", 100, -3.15, 3.15));
   vTrackProfiles_.push_back(tfd.make<TProfile>(
       "p_normchi2_vs_eta", "#chi^{2}/ndof vs. #eta;#eta_{Track};#LT #chi^{2}/ndof #GT", 100, -3.15, 3.15));
   vTrackProfiles_.push_back(
       tfd.make<TProfile>("p_kappa_vs_phi", "#kappa vs. #phi;#phi_{Track};#kappa", 100, -3.15, 3.15));
   vTrackProfiles_.push_back(
       tfd.make<TProfile>("p_kappa_vs_eta", "#kappa vs. #eta;#eta_{Track};#kappa", 100, -3.15, 3.15));
   vTrackProfiles_.push_back(tfd.make<TProfile>("p_ptResolution_vs_phi",
                                                "#delta_{p_{T}}/p_{T}^{track};#phi^{track};#delta_{p_{T}}/p_{T}^{track}",
                                                100,
                                                -3.15,
                                                3.15));
   vTrackProfiles_.push_back(tfd.make<TProfile>("p_ptResolution_vs_eta",
                                                "#delta_{p_{T}}/p_{T}^{track};#eta^{track};#delta_{p_{T}}/p_{T}^{track}",
                                                100,
                                                -3.15,
                                                3.15));
 
   vTrack2DHistos_.push_back(tfd.make<TH2F>(
       "h2_d0_vs_phi", "Transverse Impact Parameter vs. #phi;#phi_{Track};d_{0} [cm]", 100, -3.15, 3.15, 100, -1., 1.));
   vTrack2DHistos_.push_back(tfd.make<TH2F>("h2_dz_vs_phi",
                                            "Longitudinal Impact Parameter vs. #phi;#phi_{Track};d_{z} [cm]",
                                            100,
                                            -3.15,
                                            3.15,
                                            100,
                                            -100.,
                                            100.));
   vTrack2DHistos_.push_back(tfd.make<TH2F>(
       "h2_d0_vs_eta", "Transverse Impact Parameter vs. #eta;#eta_{Track};d_{0} [cm]", 100, -3.15, 3.15, 100, -1., 1.));
   vTrack2DHistos_.push_back(tfd.make<TH2F>("h2_dz_vs_eta",
                                            "Longitudinal Impact Parameter vs. #eta;#eta_{Track};d_{z} [cm]",
                                            100,
                                            -3.15,
                                            3.15,
                                            100,
                                            -100.,
                                            100.));
   vTrack2DHistos_.push_back(
       tfd.make<TH2F>("h2_chi2_vs_phi", "#chi^{2} vs. #phi;#phi_{Track};#chi^{2}", 100, -3.15, 3.15, 500, 0., 500.));
   vTrack2DHistos_.push_back(tfd.make<TH2F>("h2_chi2Prob_vs_phi",
                                            "#chi^{2} probability vs. #phi;#phi_{Track};#chi^{2} probability",
                                            100,
                                            -3.15,
                                            3.15,
                                            100,
                                            0.,
                                            1.));
   vTrack2DHistos_.push_back(tfd.make<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(tfd.make<TH2F>(
       "h2_normchi2_vs_phi", "#chi^{2}/ndof vs. #phi;#phi_{Track};#chi^{2}/ndof", 100, -3.15, 3.15, 100, 0., 10.));
   vTrack2DHistos_.push_back(
       tfd.make<TH2F>("h2_chi2_vs_eta", "#chi^{2} vs. #eta;#eta_{Track};#chi^{2}", 100, -3.15, 3.15, 500, 0., 500.));
   vTrack2DHistos_.push_back(tfd.make<TH2F>("h2_chi2Prob_vs_eta",
                                            "#chi^{2} probaility vs. #eta;#eta_{Track};#chi^{2} probability",
                                            100,
                                            -3.15,
                                            3.15,
                                            100,
                                            0.,
                                            1.));
   vTrack2DHistos_.push_back(tfd.make<TH2F>(
       "h2_normchi2_vs_eta", "#chi^{2}/ndof vs. #eta;#eta_{Track};#chi^{2}/ndof", 100, -3.15, 3.15, 100, 0., 10.));
   vTrack2DHistos_.push_back(
       tfd.make<TH2F>("h2_kappa_vs_phi", "#kappa vs. #phi;#phi_{Track};#kappa", 100, -3.15, 3.15, 100, .0, .05));
   vTrack2DHistos_.push_back(
       tfd.make<TH2F>("h2_kappa_vs_eta", "#kappa vs. #eta;#eta_{Track};#kappa", 100, -3.15, 3.15, 100, .0, .05));
   vTrack2DHistos_.push_back(tfd.make<TH2F>(
       "h2_normchi2_vs_kappa", "#kappa vs. #chi^{2}/ndof;#chi^{2}/ndof;#kappa", 100, 0., 10, 100, -.03, .03));
 
   /****************** Definition of 2-D Histos of ResX vs momenta ****************************/
   vTrack2DHistos_.push_back(tfd.make<TH2F>(
       "p_vs_resXprime_pixB", "res_{x'} vs momentum in BPix;p [GeV]; res_{x'}", 15, 0., 15., 200, -0.1, 0.1));
   vTrack2DHistos_.push_back(tfd.make<TH2F>(
       "p_vs_resXprime_pixE", "res_{x'} vs momentum in FPix;p [GeV]; res_{x'}", 15, 0., 15., 200, -0.1, 0.1));
   vTrack2DHistos_.push_back(tfd.make<TH2F>(
       "p_vs_resXprime_TIB", "res_{x'} vs momentum in TIB;p [GeV]; res_{x'}", 15, 0., 15., 200, -0.1, 0.1));
   vTrack2DHistos_.push_back(tfd.make<TH2F>(
       "p_vs_resXprime_TID", "res_{x'} vs momentum in TID;p [GeV]; res_{x'}", 15, 0., 15., 200, -0.1, 0.1));
   vTrack2DHistos_.push_back(tfd.make<TH2F>(
       "p_vs_resXprime_TOB", "res_{x'} vs momentum in TOB;p [GeV]; res_{x'}", 15, 0., 15., 200, -0.1, 0.1));
   vTrack2DHistos_.push_back(tfd.make<TH2F>(
       "p_vs_resXprime_TEC", "res_{x'} vs momentum in TEC;p [GeV]; res_{x'}", 15, 0., 15., 200, -0.1, 0.1));
 
   /****************** Definition of 2-D Histos of ResY vs momenta ****************************/
   vTrack2DHistos_.push_back(tfd.make<TH2F>(
       "p_vs_resYprime_pixB", "res_{y'} vs momentum in BPix;p [GeV]; res_{y'}", 15, 0., 15., 200, -0.1, 0.1));
   vTrack2DHistos_.push_back(tfd.make<TH2F>(
       "p_vs_resYprime_pixE", "res_{y'} vs momentum in FPix;p [GeV]; res_{y'}", 15, 0., 15., 200, -0.1, 0.1));
 }

◆ bookHists()

void TrackerOfflineValidation::bookHists	(	DirectoryWrapper &	tfd,
		const Alignable &	ali,
		const TrackerTopology *	tTopo,
		align::StructureType	type,
		int	i
	)

private

Definition at line 773 of file TrackerOfflineValidation.cc.

Referenced by bookDirHists().

                                                                                                                {
   TrackerAlignableId aliid;
   const DetId id = ali.id();
 
   // comparing subdetandlayer to subdetIds gives a warning at compile time
   // -> subdetandlayer could also be pair<uint,uint> but this has to be adapted
   // in AlignableObjId
   std::pair<int, int> subdetandlayer = aliid.typeAndLayerFromDetId(id, tTopo);
 
   align::StructureType subtype = align::invalid;
 
   // are we on or just above det, detunit level respectively?
   if (type == align::AlignableDetUnit)
     subtype = type;
   else if (this->isDetOrDetUnit(ali.alignableObjectId()))
     subtype = ali.alignableObjectId();
 
   // construct histogram title and name
   std::stringstream histoname, histotitle, normhistoname, normhistotitle, yhistoname, yhistotitle, xprimehistoname,
       xprimehistotitle, normxprimehistoname, normxprimehistotitle, yprimehistoname, yprimehistotitle,
       normyprimehistoname, normyprimehistotitle, localxname, localxtitle, localyname, localytitle, resxvsxprofilename,
       resxvsxprofiletitle, resyvsxprofilename, resyvsxprofiletitle, resxvsyprofilename, resxvsyprofiletitle,
       resyvsyprofilename, resyvsyprofiletitle;
 
   std::string wheel_or_layer;
 
   if (this->isEndCap(static_cast<uint32_t>(subdetandlayer.first)))
     wheel_or_layer = "_wheel_";
   else if (this->isBarrel(static_cast<uint32_t>(subdetandlayer.first)))
     wheel_or_layer = "_layer_";
   else
     edm::LogWarning("TrackerOfflineValidation") << "@SUB=TrackerOfflineValidation::bookHists"
                                                 << "Unknown subdetid: " << subdetandlayer.first;
 
   histoname << "h_residuals_subdet_" << subdetandlayer.first << wheel_or_layer << subdetandlayer.second << "_module_"
             << id.rawId();
   yhistoname << "h_y_residuals_subdet_" << subdetandlayer.first << wheel_or_layer << subdetandlayer.second << "_module_"
              << id.rawId();
   xprimehistoname << "h_xprime_residuals_subdet_" << subdetandlayer.first << wheel_or_layer << subdetandlayer.second
                   << "_module_" << id.rawId();
   yprimehistoname << "h_yprime_residuals_subdet_" << subdetandlayer.first << wheel_or_layer << subdetandlayer.second
                   << "_module_" << id.rawId();
   normhistoname << "h_normresiduals_subdet_" << subdetandlayer.first << wheel_or_layer << subdetandlayer.second
                 << "_module_" << id.rawId();
   normxprimehistoname << "h_normxprimeresiduals_subdet_" << subdetandlayer.first << wheel_or_layer
                       << subdetandlayer.second << "_module_" << id.rawId();
   normyprimehistoname << "h_normyprimeresiduals_subdet_" << subdetandlayer.first << wheel_or_layer
                       << subdetandlayer.second << "_module_" << id.rawId();
   histotitle << "X Residual for module " << id.rawId() << ";x_{tr} - x_{hit} [cm]";
   yhistotitle << "Y Residual for module " << id.rawId() << ";y_{tr} - y_{hit} [cm]";
   normhistotitle << "Normalized Residual for module " << id.rawId() << ";x_{tr} - x_{hit}/#sigma";
   xprimehistotitle << "X' Residual for module " << id.rawId() << ";(x_{tr} - x_{hit})' [cm]";
   normxprimehistotitle << "Normalized X' Residual for module " << id.rawId() << ";(x_{tr} - x_{hit})'/#sigma";
   yprimehistotitle << "Y' Residual for module " << id.rawId() << ";(y_{tr} - y_{hit})' [cm]";
   normyprimehistotitle << "Normalized Y' Residual for module " << id.rawId() << ";(y_{tr} - y_{hit})'/#sigma";
 
   if (moduleLevelProfiles_) {
     localxname << "h_localx_subdet_" << subdetandlayer.first << wheel_or_layer << subdetandlayer.second << "_module_"
                << id.rawId();
     localyname << "h_localy_subdet_" << subdetandlayer.first << wheel_or_layer << subdetandlayer.second << "_module_"
                << id.rawId();
     localxtitle << "u local for module " << id.rawId() << "; u_{tr,r}";
     localytitle << "v local for module " << id.rawId() << "; v_{tr,r}";
 
     resxvsxprofilename << "p_residuals_x_vs_x_subdet_" << subdetandlayer.first << wheel_or_layer
                        << subdetandlayer.second << "_module_" << id.rawId();
     resyvsxprofilename << "p_residuals_y_vs_x_subdet_" << subdetandlayer.first << wheel_or_layer
                        << subdetandlayer.second << "_module_" << id.rawId();
     resxvsyprofilename << "p_residuals_x_vs_y_subdet_" << subdetandlayer.first << wheel_or_layer
                        << subdetandlayer.second << "_module_" << id.rawId();
     resyvsyprofilename << "p_residuals_y_vs_y_subdet_" << subdetandlayer.first << wheel_or_layer
                        << subdetandlayer.second << "_module_" << id.rawId();
     resxvsxprofiletitle << "U Residual vs u for module " << id.rawId()
                         << "; u_{tr,r} ;(u_{tr} - u_{hit})/tan#alpha [cm]";
     resyvsxprofiletitle << "V Residual vs u for module " << id.rawId()
                         << "; u_{tr,r} ;(v_{tr} - v_{hit})/tan#beta  [cm]";
     resxvsyprofiletitle << "U Residual vs v for module " << id.rawId()
                         << "; v_{tr,r} ;(u_{tr} - u_{hit})/tan#alpha [cm]";
     resyvsyprofiletitle << "V Residual vs v for module " << id.rawId()
                         << "; v_{tr,r} ;(v_{tr} - v_{hit})/tan#beta  [cm]";
   }
 
   if (this->isDetOrDetUnit(subtype)) {
     ModuleHistos& histStruct = this->getHistStructFromMap(id);
     int nbins = 0;
     double xmin = 0., xmax = 0.;
     double ymin = -0.1, ymax = 0.1;
 
     // do not allow transient hists in DQM mode
     bool moduleLevelHistsTransient(moduleLevelHistsTransient_);
     if (dqmMode_)
       moduleLevelHistsTransient = false;
 
     // decide via cfg if hists in local coordinates should be booked
     if (lCoorHistOn_) {
       this->getBinning(id.subdetId(), XResidual, nbins, xmin, xmax);
       histStruct.ResHisto = this->bookTH1F(
           moduleLevelHistsTransient, tfd, histoname.str().c_str(), histotitle.str().c_str(), nbins, xmin, xmax);
       this->getBinning(id.subdetId(), NormXResidual, nbins, xmin, xmax);
       histStruct.NormResHisto = this->bookTH1F(
           moduleLevelHistsTransient, tfd, normhistoname.str().c_str(), normhistotitle.str().c_str(), nbins, xmin, xmax);
     }
     this->getBinning(id.subdetId(), XprimeResidual, nbins, xmin, xmax);
     histStruct.ResXprimeHisto = this->bookTH1F(moduleLevelHistsTransient,
                                                tfd,
                                                xprimehistoname.str().c_str(),
                                                xprimehistotitle.str().c_str(),
                                                nbins,
                                                xmin,
                                                xmax);
     this->getBinning(id.subdetId(), NormXprimeResidual, nbins, xmin, xmax);
     histStruct.NormResXprimeHisto = this->bookTH1F(moduleLevelHistsTransient,
                                                    tfd,
                                                    normxprimehistoname.str().c_str(),
                                                    normxprimehistotitle.str().c_str(),
                                                    nbins,
                                                    xmin,
                                                    xmax);
 
     if (moduleLevelProfiles_) {
       this->getBinning(id.subdetId(), XResidualProfile, nbins, xmin, xmax);
 
       histStruct.LocalX = this->bookTH1F(
           moduleLevelHistsTransient, tfd, localxname.str().c_str(), localxtitle.str().c_str(), nbins, xmin, xmax);
       histStruct.LocalY = this->bookTH1F(
           moduleLevelHistsTransient, tfd, localyname.str().c_str(), localytitle.str().c_str(), nbins, xmin, xmax);
       histStruct.ResXvsXProfile = this->bookTProfile(moduleLevelHistsTransient,
                                                      tfd,
                                                      resxvsxprofilename.str().c_str(),
                                                      resxvsxprofiletitle.str().c_str(),
                                                      nbins,
                                                      xmin,
                                                      xmax,
                                                      ymin,
                                                      ymax);
       histStruct.ResXvsXProfile->Sumw2();  // to be filled with weights, so uncertainties need sum of square of weights
       histStruct.ResXvsYProfile = this->bookTProfile(moduleLevelHistsTransient,
                                                      tfd,
                                                      resxvsyprofilename.str().c_str(),
                                                      resxvsyprofiletitle.str().c_str(),
                                                      nbins,
                                                      xmin,
                                                      xmax,
                                                      ymin,
                                                      ymax);
       histStruct.ResXvsYProfile->Sumw2();  // to be filled with weights, so uncertainties need sum of square of weights
     }
 
     if (this->isPixel(subdetandlayer.first) || stripYResiduals_) {
       this->getBinning(id.subdetId(), YprimeResidual, nbins, xmin, xmax);
       histStruct.ResYprimeHisto = this->bookTH1F(moduleLevelHistsTransient,
                                                  tfd,
                                                  yprimehistoname.str().c_str(),
                                                  yprimehistotitle.str().c_str(),
                                                  nbins,
                                                  xmin,
                                                  xmax);
       if (lCoorHistOn_) {  // un-primed y-residual
         this->getBinning(id.subdetId(), YResidual, nbins, xmin, xmax);
         histStruct.ResYHisto = this->bookTH1F(
             moduleLevelHistsTransient, tfd, yhistoname.str().c_str(), yhistotitle.str().c_str(), nbins, xmin, xmax);
       }
       this->getBinning(id.subdetId(), NormYprimeResidual, nbins, xmin, xmax);
       histStruct.NormResYprimeHisto = this->bookTH1F(moduleLevelHistsTransient,
                                                      tfd,
                                                      normyprimehistoname.str().c_str(),
                                                      normyprimehistotitle.str().c_str(),
                                                      nbins,
                                                      xmin,
                                                      xmax);
       // Here we could add un-primed normalised y-residuals if(lCoorHistOn_)...
       if (moduleLevelProfiles_) {
         this->getBinning(id.subdetId(), YResidualProfile, nbins, xmin, xmax);
 
         histStruct.ResYvsXProfile = this->bookTProfile(moduleLevelHistsTransient,
                                                        tfd,
                                                        resyvsxprofilename.str().c_str(),
                                                        resyvsxprofiletitle.str().c_str(),
                                                        nbins,
                                                        xmin,
                                                        xmax,
                                                        ymin,
                                                        ymax);
         histStruct.ResYvsXProfile->Sumw2();  // to be filled with weights, so uncertainties need sum of square of weights
         histStruct.ResYvsYProfile = this->bookTProfile(moduleLevelHistsTransient,
                                                        tfd,
                                                        resyvsyprofilename.str().c_str(),
                                                        resyvsyprofiletitle.str().c_str(),
                                                        nbins,
                                                        xmin,
                                                        xmax,
                                                        ymin,
                                                        ymax);
         histStruct.ResYvsYProfile->Sumw2();  // to be filled with weights, so uncertainties need sum of square of weights
       }
     }
   }
 }

◆ bookSummaryHists()

TrackerOfflineValidation::SummaryContainer TrackerOfflineValidation::bookSummaryHists	(	DirectoryWrapper &	tfd,
		const Alignable &	ali,
		align::StructureType	type,
		int	i
	)

private

Definition at line 1526 of file TrackerOfflineValidation.cc.

Referenced by prepareSummaryHists().

                                                                                              {
   const uint aliSize = ali.components().size();
   const align::StructureType alitype = ali.alignableObjectId();
   const align::StructureType subtype = ali.components()[0]->alignableObjectId();
   const char* aliTypeName = alignableTracker_->objectIdProvider().idToString(alitype);  // lifetime of char* OK
   const char* aliSubtypeName = alignableTracker_->objectIdProvider().idToString(subtype);
   const char* typeName = alignableTracker_->objectIdProvider().idToString(type);
 
   const DetId aliDetId = ali.id();
   // y residuals only if pixel or specially requested for strip:
   const bool bookResidY = this->isPixel(aliDetId.subdetId()) || stripYResiduals_;
 
   SummaryContainer sumContainer;
 
   // Book summary hists with one bin per component,
   // but special case for Det with two DetUnit that we want to summarize one level up
   // (e.g. in TOBRods with 12 bins for 6 stereo and 6 rphi DetUnit.)
   //    component of ali is not Det or Det with just one components
   const uint subcompSize = ali.components()[0]->components().size();
   if (subtype != align::AlignableDet || subcompSize == 1) {  // Det with 1 comp. should not exist anymore...
     const TString title(Form("Summary for substructures in %s %d;%s;", aliTypeName, i, aliSubtypeName));
 
     sumContainer.summaryXResiduals_ = tfd.make<TH1F>(
         Form("h_summaryX%s_%d", aliTypeName, i), title + "#LT #Delta x' #GT", aliSize, 0.5, aliSize + 0.5);
     sumContainer.summaryNormXResiduals_ = tfd.make<TH1F>(
         Form("h_summaryNormX%s_%d", aliTypeName, i), title + "#LT #Delta x'/#sigma #GT", aliSize, 0.5, aliSize + 0.5);
 
     if (bookResidY) {
       sumContainer.summaryYResiduals_ = tfd.make<TH1F>(
           Form("h_summaryY%s_%d", aliTypeName, i), title + "#LT #Delta y' #GT", aliSize, 0.5, aliSize + 0.5);
       sumContainer.summaryNormYResiduals_ = tfd.make<TH1F>(
           Form("h_summaryNormY%s_%d", aliTypeName, i), title + "#LT #Delta y'/#sigma #GT", aliSize, 0.5, aliSize + 0.5);
     }
 
   } else if (subtype == align::AlignableDet && subcompSize > 1) {  // fixed: was aliSize before
     if (subcompSize != 2) {                                        // strange... expect only 2 DetUnits in DS layers
       // this 2 is hardcoded factor 2 in binning below and also assumed later on
       edm::LogError("Alignment") << "@SUB=bookSummaryHists"
                                  << "Det with " << subcompSize << " components";
     }
     // title contains x-title
     const TString title(Form(
         "Summary for substructures in %s %d;%s;",
         aliTypeName,
         i,
         alignableTracker_->objectIdProvider().idToString(ali.components()[0]->components()[0]->alignableObjectId())));
 
     sumContainer.summaryXResiduals_ = tfd.make<TH1F>(
         Form("h_summaryX%s_%d", aliTypeName, i), title + "#LT #Delta x' #GT", (2 * aliSize), 0.5, 2 * aliSize + 0.5);
     sumContainer.summaryNormXResiduals_ = tfd.make<TH1F>(Form("h_summaryNormX%s_%d", aliTypeName, i),
                                                          title + "#LT #Delta x'/#sigma #GT",
                                                          (2 * aliSize),
                                                          0.5,
                                                          2 * aliSize + 0.5);
 
     if (bookResidY) {
       sumContainer.summaryYResiduals_ = tfd.make<TH1F>(
           Form("h_summaryY%s_%d", aliTypeName, i), title + "#LT #Delta y' #GT", (2 * aliSize), 0.5, 2 * aliSize + 0.5);
       sumContainer.summaryNormYResiduals_ = tfd.make<TH1F>(Form("h_summaryNormY%s_%d", aliTypeName, i),
                                                            title + "#LT #Delta y'/#sigma #GT",
                                                            (2 * aliSize),
                                                            0.5,
                                                            2 * aliSize + 0.5);
     }
 
   } else {
     edm::LogError("TrackerOfflineValidation")
         << "@SUB=TrackerOfflineValidation::bookSummaryHists"
         << "No summary histogram for hierarchy level " << aliTypeName << " in subdet " << aliDetId.subdetId();
   }
 
   // Now book hists that just sum up the residual histograms from lower levels.
   // Axis title is copied from lowest level module of structure.
   // Should be safe that y-hists are only touched if non-null pointers...
   int nbins = 0;
   double xmin = 0., xmax = 0.;
   const TString sumTitle(Form("Residual for %s %d in %s;", aliTypeName, i, typeName));
   const ModuleHistos& xTitHists = this->getHistStructFromMap(aliDetId);  // for x-axis titles
   this->getBinning(aliDetId.subdetId(), XprimeResidual, nbins, xmin, xmax);
 
   sumContainer.sumXResiduals_ = tfd.make<TH1F>(Form("h_Xprime_%s_%d", aliTypeName, i),
                                                sumTitle + xTitHists.ResXprimeHisto->GetXaxis()->GetTitle(),
                                                nbins,
                                                xmin,
                                                xmax);
 
   this->getBinning(aliDetId.subdetId(), NormXprimeResidual, nbins, xmin, xmax);
   sumContainer.sumNormXResiduals_ = tfd.make<TH1F>(Form("h_NormXprime_%s_%d", aliTypeName, i),
                                                    sumTitle + xTitHists.NormResXprimeHisto->GetXaxis()->GetTitle(),
                                                    nbins,
                                                    xmin,
                                                    xmax);
 
   if (moduleLevelProfiles_) {
     this->getBinning(aliDetId.subdetId(), XResidualProfile, nbins, xmin, xmax);
     sumContainer.sumResXvsXProfile_ = tfd.make<TProfile>(Form("p_resXX_%s_%d", aliTypeName, i),
                                                          sumTitle + xTitHists.ResXvsXProfile->GetXaxis()->GetTitle() +
                                                              ";" + xTitHists.ResXvsXProfile->GetYaxis()->GetTitle(),
                                                          nbins,
                                                          xmin,
                                                          xmax);
     sumContainer.sumResXvsXProfile_->Sumw2();
     sumContainer.sumResXvsYProfile_ = tfd.make<TProfile>(Form("p_resXY_%s_%d", aliTypeName, i),
                                                          sumTitle + xTitHists.ResXvsYProfile->GetXaxis()->GetTitle() +
                                                              ";" + xTitHists.ResXvsYProfile->GetYaxis()->GetTitle(),
                                                          nbins,
                                                          xmin,
                                                          xmax);
     sumContainer.sumResXvsYProfile_->Sumw2();
   }
 
   if (bookResidY) {
     this->getBinning(aliDetId.subdetId(), YprimeResidual, nbins, xmin, xmax);
     sumContainer.sumYResiduals_ = tfd.make<TH1F>(Form("h_Yprime_%s_%d", aliTypeName, i),
                                                  sumTitle + xTitHists.ResYprimeHisto->GetXaxis()->GetTitle(),
                                                  nbins,
                                                  xmin,
                                                  xmax);
 
     this->getBinning(aliDetId.subdetId(), NormYprimeResidual, nbins, xmin, xmax);
     sumContainer.sumNormYResiduals_ = tfd.make<TH1F>(Form("h_NormYprime_%s_%d", aliTypeName, i),
                                                      sumTitle + xTitHists.NormResYprimeHisto->GetXaxis()->GetTitle(),
                                                      nbins,
                                                      xmin,
                                                      xmax);
 
     if (moduleLevelProfiles_) {
       this->getBinning(aliDetId.subdetId(), YResidualProfile, nbins, xmin, xmax);
       sumContainer.sumResYvsXProfile_ = tfd.make<TProfile>(Form("p_resYX_%s_%d", aliTypeName, i),
                                                            sumTitle + xTitHists.ResYvsXProfile->GetXaxis()->GetTitle() +
                                                                ";" + xTitHists.ResYvsXProfile->GetYaxis()->GetTitle(),
                                                            nbins,
                                                            xmin,
                                                            xmax);
       sumContainer.sumResYvsXProfile_->Sumw2();
       sumContainer.sumResYvsYProfile_ = tfd.make<TProfile>(Form("p_resYY_%s_%d", aliTypeName, i),
                                                            sumTitle + xTitHists.ResYvsYProfile->GetXaxis()->GetTitle() +
                                                                ";" + xTitHists.ResYvsYProfile->GetYaxis()->GetTitle(),
                                                            nbins,
                                                            xmin,
                                                            xmax);
       sumContainer.sumResYvsYProfile_->Sumw2();
     }
   }
 
   // If we are at the lowest level, we already sum up and fill the summary.
 
   // special case I: For DetUnits and Dets with only one subcomponent start filling summary histos
   if ((subtype == align::AlignableDet && subcompSize == 1) || subtype == align::AlignableDetUnit) {
     for (uint k = 0; k < aliSize; ++k) {
       DetId detid = ali.components()[k]->id();
       ModuleHistos& histStruct = this->getHistStructFromMap(detid);
       this->summarizeBinInContainer(k + 1, detid.subdetId(), sumContainer, histStruct);
       sumHistStructure_.emplace_back(sumContainer.sumXResiduals_, histStruct.ResXprimeHisto);
       sumHistStructure_.emplace_back(sumContainer.sumNormXResiduals_, histStruct.NormResXprimeHisto);
       if (moduleLevelProfiles_) {
         sumHistStructure_.emplace_back(sumContainer.sumResXvsXProfile_, histStruct.ResXvsXProfile);
         sumHistStructure_.emplace_back(sumContainer.sumResXvsYProfile_, histStruct.ResXvsYProfile);
       }
       if (this->isPixel(detid.subdetId()) || stripYResiduals_) {
         sumHistStructure_.emplace_back(sumContainer.sumYResiduals_, histStruct.ResYprimeHisto);
         sumHistStructure_.emplace_back(sumContainer.sumNormYResiduals_, histStruct.NormResYprimeHisto);
         if (moduleLevelProfiles_) {
           sumHistStructure_.emplace_back(sumContainer.sumResYvsXProfile_, histStruct.ResYvsXProfile);
           sumHistStructure_.emplace_back(sumContainer.sumResYvsYProfile_, histStruct.ResYvsYProfile);
         }
       }
     }
   } else if (subtype == align::AlignableDet && subcompSize > 1) {  // fixed: was aliSize before
     // special case II: Fill summary histos for dets with two detunits
     for (uint k = 0; k < aliSize; ++k) {
       for (uint j = 0; j < subcompSize; ++j) {  // assumes all have same size (as binning does)
         DetId detid = ali.components()[k]->components()[j]->id();
         ModuleHistos& histStruct = this->getHistStructFromMap(detid);
         this->summarizeBinInContainer(2 * k + j + 1, detid.subdetId(), sumContainer, histStruct);
         sumHistStructure_.emplace_back(sumContainer.sumXResiduals_, histStruct.ResXprimeHisto);
         sumHistStructure_.emplace_back(sumContainer.sumNormXResiduals_, histStruct.NormResXprimeHisto);
         if (moduleLevelProfiles_) {
           sumHistStructure_.emplace_back(sumContainer.sumResXvsXProfile_, histStruct.ResXvsXProfile);
           sumHistStructure_.emplace_back(sumContainer.sumResXvsYProfile_, histStruct.ResXvsYProfile);
         }
         if (this->isPixel(detid.subdetId()) || stripYResiduals_) {
           sumHistStructure_.emplace_back(sumContainer.sumYResiduals_, histStruct.ResYprimeHisto);
           sumHistStructure_.emplace_back(sumContainer.sumNormYResiduals_, histStruct.NormResYprimeHisto);
           if (moduleLevelProfiles_) {
             sumHistStructure_.emplace_back(sumContainer.sumResYvsXProfile_, histStruct.ResYvsXProfile);
             sumHistStructure_.emplace_back(sumContainer.sumResYvsYProfile_, histStruct.ResYvsYProfile);
           }
         }
       }
     }
   }
   return sumContainer;
 }

◆ bookTH1F()

TH1 * TrackerOfflineValidation::bookTH1F	(	bool	isTransient,
		DirectoryWrapper &	tfd,
		const char *	histName,
		const char *	histTitle,
		int	nBinsX,
		double	lowX,
		double	highX
	)

private

Definition at line 973 of file TrackerOfflineValidation.cc.

References B2GTnPMonitor_cfi::histTitle, TrackerOfflineValidation::DirectoryWrapper::make(), and vDeleteObjects_.

Referenced by bookHists().

                                                       {
   if (isTransient) {
     vDeleteObjects_.push_back(new TH1F(histName, histTitle, nBinsX, lowX, highX));
     return vDeleteObjects_.back();  // return last element of vector
   } else
     return tfd.make<TH1F>(histName, histTitle, nBinsX, lowX, highX);
 }

◆ bookTProfile() [1/2]

TProfile * TrackerOfflineValidation::bookTProfile	(	bool	isTransient,
		DirectoryWrapper &	tfd,
		const char *	histName,
		const char *	histTitle,
		int	nBinsX,
		double	lowX,
		double	highX
	)

private

Definition at line 987 of file TrackerOfflineValidation.cc.

References B2GTnPMonitor_cfi::histTitle, TrackerOfflineValidation::DirectoryWrapper::make(), PostProcessor_cff::profile, and vDeleteObjects_.

Referenced by bookHists().

                                                                {
   if (isTransient) {
     TProfile* profile = new TProfile(histName, histTitle, nBinsX, lowX, highX);
     vDeleteObjects_.push_back(profile);
     return profile;
   } else
     return (TProfile*)tfd.make<TProfile>(histName, histTitle, nBinsX, lowX, highX);
 }

◆ bookTProfile() [2/2]

TProfile * TrackerOfflineValidation::bookTProfile	(	bool	isTransient,
		DirectoryWrapper &	tfd,
		const char *	histName,
		const char *	histTitle,
		int	nBinsX,
		double	lowX,
		double	highX,
		double	lowY,
		double	highY
	)

private

Definition at line 1002 of file TrackerOfflineValidation.cc.

References B2GTnPMonitor_cfi::histTitle, TrackerOfflineValidation::DirectoryWrapper::make(), PostProcessor_cff::profile, and vDeleteObjects_.

                                                                {
   if (isTransient) {
     TProfile* profile = new TProfile(histName, histTitle, nBinsX, lowX, highX, lowY, highY);
     vDeleteObjects_.push_back(profile);
     return profile;
   } else
     return (TProfile*)tfd.make<TProfile>(histName, histTitle, nBinsX, lowX, highX, lowY, highY);
 }

◆ checkBookHists()

void TrackerOfflineValidation::checkBookHists ( const edm::EventSetup & setup )

privatevirtual

Definition at line 553 of file TrackerOfflineValidation.cc.

References alignableTracker_, bareTkGeomPtr_, bookDirHists(), bookGlobalHists(), TrackerGeometry::detIds(), TrackerGeometry::detUnitIds(), dqmMode_, geomToken_, edm::EventSetup::getData(), edm::EventSetup::getHandle(), moduleDirectory_, mPxbResiduals_, mPxeResiduals_, mTecResiduals_, mTibResiduals_, mTidResiduals_, mTobResiduals_, prepareSummaryHists(), setUpTreeMembers(), AlCaHLTBitMon_QueryRunRegistry::string, tkGeom_, and topoToken_.

Referenced by analyze().

                                                                      {
   tkGeom_ = es.getHandle(geomToken_);
   const TrackerGeometry* newBareTkGeomPtr = &(*tkGeom_);
 
   if (newBareTkGeomPtr == bareTkGeomPtr_)
     return;  // already booked hists, nothing changed
 
   if (!bareTkGeomPtr_) {  // pointer not yet set: called the first time => book hists
 
     //Retrieve tracker topology from geometry
     const TrackerTopology* const tTopo = &es.getData(topoToken_);
 
     // construct alignable tracker to get access to alignable hierarchy
     alignableTracker_ = std::make_unique<AlignableTracker>(&(*tkGeom_), tTopo);
 
     edm::LogInfo("TrackerOfflineValidation")
         << "There are " << newBareTkGeomPtr->detIds().size() << " dets in the Geometry record.\n"
         << "Out of these " << newBareTkGeomPtr->detUnitIds().size() << " are detUnits";
 
     // Book histograms for global track quantities
     std::string globDir("GlobalTrackVariables");
     DirectoryWrapper trackglobal(globDir, moduleDirectory_, dqmMode_);
     this->bookGlobalHists(trackglobal);
 
     // recursively book histograms on lowest level
     DirectoryWrapper tfdw("", moduleDirectory_, dqmMode_);
     this->bookDirHists(tfdw, *alignableTracker_, tTopo);
     // and prepare the higher level histograms
     std::vector<TrackerOfflineValidation::SummaryContainer> vTrackerprofiles;
     this->prepareSummaryHists(tfdw, *alignableTracker_, vTrackerprofiles);
 
     setUpTreeMembers(mPxbResiduals_, *newBareTkGeomPtr, tTopo);
     setUpTreeMembers(mPxeResiduals_, *newBareTkGeomPtr, tTopo);
     setUpTreeMembers(mTibResiduals_, *newBareTkGeomPtr, tTopo);
     setUpTreeMembers(mTidResiduals_, *newBareTkGeomPtr, tTopo);
     setUpTreeMembers(mTobResiduals_, *newBareTkGeomPtr, tTopo);
     setUpTreeMembers(mTecResiduals_, *newBareTkGeomPtr, tTopo);
   } else {  // histograms booked, but changed TrackerGeometry?
     edm::LogWarning("GeometryChange") << "@SUB=checkBookHists"
                                       << "TrackerGeometry changed, but will not re-book hists!";
   }
   bareTkGeomPtr_ = newBareTkGeomPtr;
 }

◆ collateSummaryHists()

void TrackerOfflineValidation::collateSummaryHists ( )

private

Definition at line 1512 of file TrackerOfflineValidation.cc.

References fitResiduals(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, setSummaryBin(), sumHistStructure_, summaryBins_, toFit_, and trackerHitRTTI::vector.

Referenced by endJob().

                                                    {
   for (std::vector<std::pair<TH1*, TH1*> >::const_iterator it = sumHistStructure_.begin();
        it != sumHistStructure_.end();
        ++it)
     it->first->Add(it->second);
 
   for (std::vector<std::tuple<int, TH1*, TH1*> >::const_iterator it = summaryBins_.begin(); it != summaryBins_.end();
        ++it)
     setSummaryBin(std::get<0>(*it), std::get<1>(*it), std::get<2>(*it));
 
   for (std::vector<TH1*>::const_iterator it = toFit_.begin(); it != toFit_.end(); ++it)
     fitResiduals(*it);
 }

◆ endJob()

void TrackerOfflineValidation::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 1404 of file TrackerOfflineValidation.cc.

References collateSummaryHists(), compressionSettings_, dqmMode_, fillTree(), compareTotals::fs, GetIndex(), mPxbResiduals_, mPxeResiduals_, mTecResiduals_, mTibResiduals_, mTidResiduals_, mTobResiduals_, edm::ESHandle< T >::product(), tkGeom_, and vTrackHistos_.

Referenced by o2olib.O2ORunMgr::executeJob().

                                       {
   if (!tkGeom_.product())
     return;
 
   static const int kappadiffindex = this->GetIndex(vTrackHistos_, "h_diff_curvature");
   vTrackHistos_[kappadiffindex]->Add(vTrackHistos_[this->GetIndex(vTrackHistos_, "h_curvature_neg")],
                                      vTrackHistos_[this->GetIndex(vTrackHistos_, "h_curvature_pos")],
                                      -1,
                                      1);
 
   // Collate Information for Subdetectors
   // create summary histograms recursively
   this->collateSummaryHists();
 
   if (dqmMode_)
     return;
   // Should be excluded in dqmMode, since TTree is not usable
   // In dqmMode tree operations are are sourced out to the additional module TrackerOfflineValidationSummary
 
   edm::Service<TFileService> fs;
   if (compressionSettings_ > 0) {
     fs->file().SetCompressionSettings(compressionSettings_);
   }
 
   TTree* tree = fs->make<TTree>("TkOffVal", "TkOffVal");
 
   TkOffTreeVariables* treeMemPtr = new TkOffTreeVariables;
   // We create branches for all members of 'TkOffTreeVariables' (even if not needed).
   // This works because we have a dictionary for 'TkOffTreeVariables'
   // (see src/classes_def.xml and src/classes.h):
   tree->Branch("TkOffTreeVariables", &treeMemPtr);  // address of pointer!
 
   this->fillTree(*tree, *treeMemPtr, mPxbResiduals_);
   this->fillTree(*tree, *treeMemPtr, mPxeResiduals_);
   this->fillTree(*tree, *treeMemPtr, mTibResiduals_);
   this->fillTree(*tree, *treeMemPtr, mTidResiduals_);
   this->fillTree(*tree, *treeMemPtr, mTobResiduals_);
   this->fillTree(*tree, *treeMemPtr, mTecResiduals_);
 
   delete treeMemPtr;
   treeMemPtr = nullptr;
 }

◆ fillDescriptions()

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

static

Definition at line 496 of file TrackerOfflineValidation.cc.

References edm::ParameterSetDescription::add(), edm::ConfigurationDescriptions::addWithDefaultLabel(), submitPVResolutionJobs::desc, TrackerValidationVariables::fillPSetDescription(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                           {
   edm::ParameterSetDescription desc;
   desc.setComment("Validates alignment payloads by evaluating unbiased track-hit resisuals");
   TrackerValidationVariables::fillPSetDescription(desc);
   desc.addUntracked<int>("compressionSettings", -1);
   desc.add<bool>("localCoorHistosOn", false);
   desc.add<bool>("moduleLevelHistsTransient", false);
   desc.add<bool>("moduleLevelProfiles", false);
   desc.add<bool>("stripYResiduals", false);
   desc.add<bool>("useFwhm", true);
   desc.add<bool>("useFit", false);
   desc.add<bool>("useOverflowForRMS", false);
   desc.add<bool>("useInDqmMode", false);
   desc.add<std::string>("moduleDirectoryInOutput", {});
   desc.add<int>("chargeCut", 0);
   desc.add<unsigned long long>("maxTracks", 0);
 
   // fill in the residuals details
   std::vector<std::string> listOfResidualsPSets = {"TH1XResPixelModules",
                                                    "TH1XResStripModules",
                                                    "TH1NormXResPixelModules",
                                                    "TH1NormXResStripModules",
                                                    "TH1XprimeResPixelModules",
                                                    "TH1XprimeResStripModules",
                                                    "TH1NormXprimeResPixelModules",
                                                    "TH1NormXprimeResStripModules",
                                                    "TH1YResPixelModules",
                                                    "TH1YResStripModules",
                                                    "TH1NormYResPixelModules",
                                                    "TH1NormYResStripModules",
                                                    "TProfileXResPixelModules",
                                                    "TProfileXResStripModules",
                                                    "TProfileYResPixelModules",
                                                    "TProfileYResStripModules"};
 
   for (const auto& myPSetName : listOfResidualsPSets) {
     edm::ParameterSetDescription myPSet;
     myPSet.add<int>("Nbinx", 100);
     myPSet.add<double>("xmin", -5.f);
     myPSet.add<double>("xmax", 5.f);
     desc.add<edm::ParameterSetDescription>(myPSetName, myPSet);
   }
   descriptions.addWithDefaultLabel(desc);
 }

◆ fillTree()

void TrackerOfflineValidation::fillTree	(	TTree &	tree,
		TkOffTreeVariables &	treeMem,
		const std::map< int, TrackerOfflineValidation::ModuleHistos > &	moduleHist_
	)

private

Definition at line 1887 of file TrackerOfflineValidation.cc.

Referenced by endJob(), and core.AutoFillTreeProducer.AutoFillTreeProducer::process().

                                                                                                               {
   for (std::map<int, TrackerOfflineValidation::ModuleHistos>::const_iterator it = moduleHist_.begin(),
                                                                              itEnd = moduleHist_.end();
        it != itEnd;
        ++it) {
     treeMem = mTreeMembers_[it->first];
 
     //mean and RMS values (extracted from histograms(Xprime on module level)
     treeMem.entries = static_cast<UInt_t>(it->second.ResXprimeHisto->GetEntries());
     treeMem.meanX = it->second.ResXprimeHisto->GetMean();
     treeMem.rmsX = it->second.ResXprimeHisto->GetRMS();
     //treeMem.sigmaX = Fwhm(it->second.ResXprimeHisto)/2.355;
 
     if (useFit_) {
       //call fit function which returns mean and sigma from the fit
       //for absolute residuals
       std::pair<float, float> fitResult1 = this->fitResiduals(it->second.ResXprimeHisto);
       treeMem.fitMeanX = fitResult1.first;
       treeMem.fitSigmaX = fitResult1.second;
       //for normalized residuals
       std::pair<float, float> fitResult2 = this->fitResiduals(it->second.NormResXprimeHisto);
       treeMem.fitMeanNormX = fitResult2.first;
       treeMem.fitSigmaNormX = fitResult2.second;
     }
 
     //get median for absolute residuals
     treeMem.medianX = this->getMedian(it->second.ResXprimeHisto);
 
     int numberOfBins = it->second.ResXprimeHisto->GetNbinsX();
     treeMem.numberOfUnderflows = it->second.ResXprimeHisto->GetBinContent(0);
     treeMem.numberOfOverflows = it->second.ResXprimeHisto->GetBinContent(numberOfBins + 1);
     treeMem.numberOfOutliers =
         it->second.ResXprimeHisto->GetBinContent(0) + it->second.ResXprimeHisto->GetBinContent(numberOfBins + 1);
 
     //mean and RMS values (extracted from histograms(normalized Xprime on module level)
     treeMem.meanNormX = it->second.NormResXprimeHisto->GetMean();
     treeMem.rmsNormX = it->second.NormResXprimeHisto->GetRMS();
 
     double stats[20];
     it->second.NormResXprimeHisto->GetStats(stats);
     // GF  treeMem.chi2PerDofX = stats[3]/(stats[0]-1);
     if (stats[0])
       treeMem.chi2PerDofX = stats[3] / stats[0];
 
     treeMem.sigmaNormX = Fwhm(it->second.NormResXprimeHisto) / 2.355;
     treeMem.histNameX = it->second.ResXprimeHisto->GetName();
     treeMem.histNameNormX = it->second.NormResXprimeHisto->GetName();
 
     // fill tree variables in local coordinates if set in cfg
     if (lCoorHistOn_) {
       treeMem.meanLocalX = it->second.ResHisto->GetMean();
       treeMem.rmsLocalX = it->second.ResHisto->GetRMS();
       treeMem.meanNormLocalX = it->second.NormResHisto->GetMean();
       treeMem.rmsNormLocalX = it->second.NormResHisto->GetRMS();
 
       treeMem.histNameLocalX = it->second.ResHisto->GetName();
       treeMem.histNameNormLocalX = it->second.NormResHisto->GetName();
       if (it->second.ResYHisto)
         treeMem.histNameLocalY = it->second.ResYHisto->GetName();
     }
 
     // mean and RMS values in local y (extracted from histograms(normalized Yprime on module level)
     // might exist in pixel only
     if (it->second.ResYprimeHisto) {  //(stripYResiduals_)
       TH1* h = it->second.ResYprimeHisto;
       treeMem.meanY = h->GetMean();
       treeMem.rmsY = h->GetRMS();
 
       if (useFit_) {  // fit function which returns mean and sigma from the fit
         std::pair<float, float> fitMeanSigma = this->fitResiduals(h);
         treeMem.fitMeanY = fitMeanSigma.first;
         treeMem.fitSigmaY = fitMeanSigma.second;
       }
 
       //get median for absolute residuals
       treeMem.medianY = this->getMedian(h);
 
       treeMem.histNameY = h->GetName();
     }
     if (it->second.NormResYprimeHisto) {
       TH1* h = it->second.NormResYprimeHisto;
       treeMem.meanNormY = h->GetMean();
       treeMem.rmsNormY = h->GetRMS();
       h->GetStats(stats);  // stats buffer defined above
       if (stats[0])
         treeMem.chi2PerDofY = stats[3] / stats[0];
 
       if (useFit_) {  // fit function which returns mean and sigma from the fit
         std::pair<float, float> fitMeanSigma = this->fitResiduals(h);
         treeMem.fitMeanNormY = fitMeanSigma.first;
         treeMem.fitSigmaNormY = fitMeanSigma.second;
       }
       treeMem.histNameNormY = h->GetName();
     }
 
     if (moduleLevelProfiles_) {
       if (it->second.ResXvsXProfile) {
         TH1* h = it->second.ResXvsXProfile;
         treeMem.meanResXvsX = h->GetMean();
         treeMem.rmsResXvsX = h->GetRMS();
         treeMem.profileNameResXvsX = h->GetName();
       }
       if (it->second.ResXvsYProfile) {
         TH1* h = it->second.ResXvsYProfile;
         treeMem.meanResXvsY = h->GetMean();
         treeMem.rmsResXvsY = h->GetRMS();
         treeMem.profileNameResXvsY = h->GetName();
       }
       if (it->second.ResYvsXProfile) {
         TH1* h = it->second.ResYvsXProfile;
         treeMem.meanResYvsX = h->GetMean();
         treeMem.rmsResYvsX = h->GetRMS();
         treeMem.profileNameResYvsX = h->GetName();
       }
       if (it->second.ResYvsYProfile) {
         TH1* h = it->second.ResYvsYProfile;
         treeMem.meanResYvsY = h->GetMean();
         treeMem.rmsResYvsY = h->GetRMS();
         treeMem.profileNameResYvsY = h->GetName();
       }
     }
 
     tree.Fill();
   }
 }

◆ fitResiduals()

std::pair< float, float > TrackerOfflineValidation::fitResiduals ( TH1 * hist ) const

private

Definition at line 2015 of file TrackerOfflineValidation.cc.

References MillePedeFileConverter_cfg::e, EcalMonitorTask_cff::func, compareTotals::hist, and SiStripPI::mean.

Referenced by collateSummaryHists(), and fillTree().

                                                                             {
   std::pair<float, float> fitResult(9999., 9999.);
   if (!hist || hist->GetEntries() < 20)
     return fitResult;
 
   float mean = hist->GetMean();
   float sigma = hist->GetRMS();
 
   try {  // for < CMSSW_2_2_0 since ROOT warnings from fit are converted to exceptions
     // Remove the try/catch for more recent CMSSW!
     // first fit: two RMS around mean
     TF1 func("tmp", "gaus", mean - 2. * sigma, mean + 2. * sigma);
     if (0 == hist->Fit(&func, "QNR")) {  // N: do not blow up file by storing fit!
       mean = func.GetParameter(1);
       sigma = func.GetParameter(2);
       // second fit: three sigma of first fit around mean of first fit
       func.SetRange(mean - 3. * sigma, mean + 3. * sigma);
       // I: integral gives more correct results if binning is too wide
       // L: Likelihood can treat empty bins correctly (if hist not weighted...)
       if (0 == hist->Fit(&func, "Q0LR")) {
         if (hist->GetFunction(func.GetName())) {  // Take care that it is later on drawn:
           hist->GetFunction(func.GetName())->ResetBit(TF1::kNotDraw);
         }
         fitResult.first = func.GetParameter(1);
         fitResult.second = func.GetParameter(2);
       }
     }
   } catch (cms::Exception const& e) {
     edm::LogWarning("Alignment") << "@SUB=TrackerOfflineValidation::fitResiduals"
                                  << "Caught this exception during ROOT fit: " << e.what();
   }
   return fitResult;
 }

◆ Fwhm()

float TrackerOfflineValidation::Fwhm ( const TH1 * hist ) const

private

Definition at line 1724 of file TrackerOfflineValidation.cc.

References compareTotals::hist, mps_fire::i, and SiStripPI::max.

Referenced by fillTree(), and setSummaryBin().

                                                           {
   float max = hist->GetMaximum();
   int left = -1, right = -1;
   for (unsigned int i = 1, iEnd = hist->GetNbinsX(); i <= iEnd; ++i) {
     if (hist->GetBinContent(i) < max / 2. && hist->GetBinContent(i + 1) > max / 2. && left == -1) {
       if (max / 2. - hist->GetBinContent(i) < hist->GetBinContent(i + 1) - max / 2.) {
         left = i;
         ++i;
       } else {
         left = i + 1;
         ++i;
       }
     }
     if (left != -1 && right == -1) {
       if (hist->GetBinContent(i) > max / 2. && hist->GetBinContent(i + 1) < max / 2.) {
         if (hist->GetBinContent(i) - max / 2. < max / 2. - hist->GetBinContent(i + 1)) {
           right = i;
         } else {
           right = i + 1;
         }
       }
     }
   }
   return hist->GetXaxis()->GetBinCenter(right) - hist->GetXaxis()->GetBinCenter(left);
 }

◆ getBinning()

void TrackerOfflineValidation::getBinning	(	uint32_t	subDetId,
		TrackerOfflineValidation::HistogramType	residualtype,
		int &	nBinsX,
		double &	lowerBoundX,
		double &	upperBoundX
	)

private

Definition at line 1037 of file TrackerOfflineValidation.cc.

References edm::ParameterSet::getParameter(), isPixel(), NormXprimeResidual, NormXResidual, NormYprimeResidual, parSet_, XprimeResidual, XResidual, XResidualProfile, YprimeResidual, YResidual, and YResidualProfile.

Referenced by bookHists(), and bookSummaryHists().

                                                                {
   // determine if
   const bool isPixel = this->isPixel(subDetId);
 
   edm::ParameterSet binningPSet;
 
   switch (residualType) {
     case XResidual:
       if (isPixel)
         binningPSet = parSet_.getParameter<edm::ParameterSet>("TH1XResPixelModules");
       else
         binningPSet = parSet_.getParameter<edm::ParameterSet>("TH1XResStripModules");
       break;
     case NormXResidual:
       if (isPixel)
         binningPSet = parSet_.getParameter<edm::ParameterSet>("TH1NormXResPixelModules");
       else
         binningPSet = parSet_.getParameter<edm::ParameterSet>("TH1NormXResStripModules");
       break;
     case XprimeResidual:
       if (isPixel)
         binningPSet = parSet_.getParameter<edm::ParameterSet>("TH1XprimeResPixelModules");
       else
         binningPSet = parSet_.getParameter<edm::ParameterSet>("TH1XprimeResStripModules");
       break;
     case NormXprimeResidual:
       if (isPixel)
         binningPSet = parSet_.getParameter<edm::ParameterSet>("TH1NormXprimeResPixelModules");
       else
         binningPSet = parSet_.getParameter<edm::ParameterSet>("TH1NormXprimeResStripModules");
       break;
     case YResidual:  // borrow y-residual binning from yprime
     case YprimeResidual:
       if (isPixel)
         binningPSet = parSet_.getParameter<edm::ParameterSet>("TH1YResPixelModules");
       else
         binningPSet = parSet_.getParameter<edm::ParameterSet>("TH1YResStripModules");
       break;
       /* case NormYResidual :*/
     case NormYprimeResidual:
       if (isPixel)
         binningPSet = parSet_.getParameter<edm::ParameterSet>("TH1NormYResPixelModules");
       else
         binningPSet = parSet_.getParameter<edm::ParameterSet>("TH1NormYResStripModules");
       break;
     case XResidualProfile:
       if (isPixel)
         binningPSet = parSet_.getParameter<edm::ParameterSet>("TProfileXResPixelModules");
       else
         binningPSet = parSet_.getParameter<edm::ParameterSet>("TProfileXResStripModules");
       break;
     case YResidualProfile:
       if (isPixel)
         binningPSet = parSet_.getParameter<edm::ParameterSet>("TProfileYResPixelModules");
       else
         binningPSet = parSet_.getParameter<edm::ParameterSet>("TProfileYResStripModules");
       break;
   }
   nBinsX = binningPSet.getParameter<int32_t>("Nbinx");
   lowerBoundX = binningPSet.getParameter<double>("xmin");
   upperBoundX = binningPSet.getParameter<double>("xmax");
 }

◆ getHistStructFromMap()

TrackerOfflineValidation::ModuleHistos & TrackerOfflineValidation::getHistStructFromMap ( const DetId & detid )

private

Definition at line 1138 of file TrackerOfflineValidation.cc.

References DetId::det(), Exception, mPxbResiduals_, mPxeResiduals_, mTecResiduals_, mTibResiduals_, mTidResiduals_, mTobResiduals_, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, DetId::rawId(), DetId::subdetId(), StripSubdetector::TEC, StripSubdetector::TIB, StripSubdetector::TID, StripSubdetector::TOB, and parallelization::uint.

Referenced by analyze(), bookHists(), and bookSummaryHists().

                                                                                                        {
   // get a struct with histograms from the respective map
   // if no object exist, the reference is automatically created by the map
   // throw exception if non-tracker id is passed
   uint subdetid = detid.subdetId();
   if (subdetid == PixelSubdetector::PixelBarrel) {
     return mPxbResiduals_[detid.rawId()];
   } else if (subdetid == PixelSubdetector::PixelEndcap) {
     return mPxeResiduals_[detid.rawId()];
   } else if (subdetid == StripSubdetector::TIB) {
     return mTibResiduals_[detid.rawId()];
   } else if (subdetid == StripSubdetector::TID) {
     return mTidResiduals_[detid.rawId()];
   } else if (subdetid == StripSubdetector::TOB) {
     return mTobResiduals_[detid.rawId()];
   } else if (subdetid == StripSubdetector::TEC) {
     return mTecResiduals_[detid.rawId()];
   } else {
     throw cms::Exception("Geometry Error")
         << "[TrackerOfflineValidation] Error, tried to get reference for non-tracker subdet " << subdetid
         << " from detector " << detid.det();
     return mPxbResiduals_[0];
   }
 }

◆ GetIndex()

template<class OBJECT_TYPE >

int TrackerOfflineValidation::GetIndex	(	const std::vector< OBJECT_TYPE *> &	vec,
		const TString &	name
	)

private

Definition at line 389 of file TrackerOfflineValidation.cc.

References Skims_PA_cff::name, and mps_fire::result.

Referenced by analyze(), and endJob().

                                                                                               {
   int result = 0;
   for (typename std::vector<OBJECT_TYPE*>::const_iterator iter = vec.begin(), iterEnd = vec.end(); iter != iterEnd;
        ++iter, ++result) {
     if (*iter && (*iter)->GetName() == name)
       return result;
   }
   edm::LogError("Alignment") << "@SUB=TrackerOfflineValidation::GetIndex"
                              << " could not find " << name;
   return -1;
 }

◆ getMedian()

float TrackerOfflineValidation::getMedian ( const TH1 * hist ) const

private

Definition at line 2049 of file TrackerOfflineValidation.cc.

References timingPdfMaker::histo, dqmiolumiharvest::j, median(), LaserClient_cfi::nbins, x, and y.

Referenced by fillTree().

                                                                 {
   float median = 999;
   int nbins = histo->GetNbinsX();
 
   //extract median from histogram
   double* x = new double[nbins];
   double* y = new double[nbins];
   for (int j = 0; j < nbins; j++) {
     x[j] = histo->GetBinCenter(j + 1);
     y[j] = histo->GetBinContent(j + 1);
   }
   median = TMath::Median(nbins, x, y);
 
   delete[] x;
   x = nullptr;
   delete[] y;
   y = nullptr;
 
   return median;
 }

◆ isBarrel()

bool TrackerOfflineValidation::isBarrel ( uint32_t subDetId )

private

Definition at line 1019 of file TrackerOfflineValidation.cc.

References PixelSubdetector::PixelBarrel, GeomDetEnumerators::subDetId, StripSubdetector::TIB, and StripSubdetector::TOB.

Referenced by bookHists().

                                                          {
   return (subDetId == StripSubdetector::TIB || subDetId == StripSubdetector::TOB ||
           subDetId == PixelSubdetector::PixelBarrel);
 }

◆ isDetOrDetUnit()

bool TrackerOfflineValidation::isDetOrDetUnit ( align::StructureType type )

private

Definition at line 1033 of file TrackerOfflineValidation.cc.

References align::AlignableDet, and align::AlignableDetUnit.

Referenced by bookDirHists(), bookHists(), and prepareSummaryHists().

                                                                      {
   return (type == align::AlignableDet || type == align::AlignableDetUnit);
 }

◆ isEndCap()

bool TrackerOfflineValidation::isEndCap ( uint32_t subDetId )

private

Definition at line 1024 of file TrackerOfflineValidation.cc.

References PixelSubdetector::PixelEndcap, GeomDetEnumerators::subDetId, StripSubdetector::TEC, and StripSubdetector::TID.

Referenced by bookHists().

                                                          {
   return (subDetId == StripSubdetector::TID || subDetId == StripSubdetector::TEC ||
           subDetId == PixelSubdetector::PixelEndcap);
 }

◆ isPixel()

bool TrackerOfflineValidation::isPixel ( uint32_t subDetId )

private

Definition at line 1029 of file TrackerOfflineValidation.cc.

References PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, and GeomDetEnumerators::subDetId.

Referenced by analyze(), bookHists(), bookSummaryHists(), getBinning(), and summarizeBinInContainer().

                                                         {
   return (subDetId == PixelSubdetector::PixelBarrel || subDetId == PixelSubdetector::PixelEndcap);
 }

◆ prepareSummaryHists()

void TrackerOfflineValidation::prepareSummaryHists	(	DirectoryWrapper &	tfd,
		const Alignable &	ali,
		std::vector< TrackerOfflineValidation::SummaryContainer > &	vLevelProfiles
	)

private

Definition at line 1447 of file TrackerOfflineValidation.cc.

References Alignable::alignableObjectId(), alignableTracker_, bookSummaryHists(), makeMuonMisalignmentScenario::components, Alignable::components(), BTVHLTOfflineSource_cfi::dirname, dqmMode_, f, isDetOrDetUnit(), LogDebug, moduleDirectory_, dqmiodumpmetadata::n, findQualityFiles::size, AlCaHLTBitMon_QueryRunRegistry::string, sumHistStructure_, summarizeBinInContainer(), toFit_, and parallelization::uint.

Referenced by checkBookHists().

                                                                          {
   const auto& alivec = ali.components();
   if (this->isDetOrDetUnit((alivec)[0]->alignableObjectId()))
     return;
 
   for (int iComp = 0, iCompEnd = ali.components().size(); iComp < iCompEnd; ++iComp) {
     std::vector<TrackerOfflineValidation::SummaryContainer> vProfiles;
     std::string structurename = alignableTracker_->objectIdProvider().idToString((alivec)[iComp]->alignableObjectId());
 
     LogDebug("TrackerOfflineValidation") << "StructureName = " << structurename;
     std::stringstream dirname;
     dirname << structurename;
 
     // add no suffix counter to strip and pixel -> just aesthetics
     if (structurename != "Strip" && structurename != "Pixel")
       dirname << "_" << iComp + 1;
 
     if (!(this->isDetOrDetUnit((alivec)[iComp]->alignableObjectId())) || (alivec)[0]->components().size() > 1) {
       DirectoryWrapper f(tfd, dirname.str(), moduleDirectory_, dqmMode_);
       this->prepareSummaryHists(f, *(alivec)[iComp], vProfiles);
       vLevelProfiles.push_back(this->bookSummaryHists(tfd, *(alivec[iComp]), ali.alignableObjectId(), iComp + 1));
       TH1* hX = vLevelProfiles[iComp].sumXResiduals_;
       TH1* hNormX = vLevelProfiles[iComp].sumNormXResiduals_;
       TH1* hY = vLevelProfiles[iComp].sumYResiduals_;
       TH1* hNormY = vLevelProfiles[iComp].sumNormYResiduals_;
       TH1* pXX = vLevelProfiles[iComp].sumResXvsXProfile_;
       TH1* pXY = vLevelProfiles[iComp].sumResXvsYProfile_;
       TH1* pYX = vLevelProfiles[iComp].sumResYvsXProfile_;
       TH1* pYY = vLevelProfiles[iComp].sumResYvsYProfile_;
       for (uint n = 0; n < vProfiles.size(); ++n) {
         this->summarizeBinInContainer(n + 1, vLevelProfiles[iComp], vProfiles[n]);
         sumHistStructure_.emplace_back(hX, vProfiles[n].sumXResiduals_);
         sumHistStructure_.emplace_back(hNormX, vProfiles[n].sumNormXResiduals_);
         if (hY)
           sumHistStructure_.emplace_back(hY, vProfiles[n].sumYResiduals_);  // only if existing
         if (hNormY)
           sumHistStructure_.emplace_back(hNormY, vProfiles[n].sumNormYResiduals_);  // ditto (pxl, stripYResiduals_)
         if (pXX)
           sumHistStructure_.emplace_back(pXX, vProfiles[n].sumResXvsXProfile_);
         if (pXY)
           sumHistStructure_.emplace_back(pXY, vProfiles[n].sumResXvsYProfile_);
         if (pYX)
           sumHistStructure_.emplace_back(pYX, vProfiles[n].sumResYvsXProfile_);
         if (pYY)
           sumHistStructure_.emplace_back(pYY, vProfiles[n].sumResYvsYProfile_);
       }
       if (dqmMode_)
         continue;  // No fits in dqmMode
       //add fit values to stat box
       toFit_.push_back(vLevelProfiles[iComp].sumXResiduals_);
       toFit_.push_back(vLevelProfiles[iComp].sumNormXResiduals_);
       if (hY)
         toFit_.push_back(hY);  // only if existing (pixel or stripYResiduals_)
       if (hNormY)
         toFit_.push_back(hNormY);  // ditto
     } else {
       // nothing to be done for det or detunits
       continue;
     }
   }
 }

◆ setSummaryBin()

void TrackerOfflineValidation::setSummaryBin	(	int	bin,
		TH1 *	targetHist,
		TH1 *	sourceHist
	)

private

Definition at line 1104 of file TrackerOfflineValidation.cc.

References newFWLiteAna::bin, Fwhm(), and useFwhm_.

Referenced by collateSummaryHists().

                                                                                       {
   if (targetHist && sourceHist) {
     targetHist->SetBinContent(bin, sourceHist->GetMean(1));
     if (useFwhm_)
       targetHist->SetBinError(bin, Fwhm(sourceHist) / 2.);
     else
       targetHist->SetBinError(bin, sourceHist->GetRMS(1));
   } else
     return;
 }

◆ setUpTreeMembers()

void TrackerOfflineValidation::setUpTreeMembers	(	const std::map< int, TrackerOfflineValidation::ModuleHistos > &	moduleHist_,
		const TrackerGeometry &	tkgeom,
		const TrackerTopology *	tTopo
	)

private

Definition at line 1750 of file TrackerOfflineValidation.cc.

Referenced by checkBookHists().

                                                                               {
   for (std::map<int, TrackerOfflineValidation::ModuleHistos>::const_iterator it = moduleHist_.begin(),
                                                                              itEnd = moduleHist_.end();
        it != itEnd;
        ++it) {
     TkOffTreeVariables& treeMem = mTreeMembers_[it->first];
 
     //variables concerning the tracker components/hierarchy levels
     DetId detId_ = it->first;
     treeMem.moduleId = detId_;
     treeMem.subDetId = detId_.subdetId();
     treeMem.isDoubleSide = false;
 
     if (treeMem.subDetId == PixelSubdetector::PixelBarrel) {
       unsigned int whichHalfBarrel(1), rawId(detId_.rawId());  //DetId does not know about halfBarrels is PXB ...
       if ((rawId >= 302056964 && rawId < 302059300) || (rawId >= 302123268 && rawId < 302127140) ||
           (rawId >= 302189572 && rawId < 302194980))
         whichHalfBarrel = 2;
       treeMem.layer = tTopo->pxbLayer(detId_);
       treeMem.half = whichHalfBarrel;
       treeMem.rod = tTopo->pxbLadder(detId_);  // ... so, ladder is not per halfBarrel-Layer, but per barrel-layer!
       treeMem.module = tTopo->pxbModule(detId_);
     } else if (treeMem.subDetId == PixelSubdetector::PixelEndcap) {
       unsigned int whichHalfCylinder(1), rawId(detId_.rawId());  //DetId does not kmow about halfCylinders in PXF
       if ((rawId >= 352394500 && rawId < 352406032) || (rawId >= 352460036 && rawId < 352471568) ||
           (rawId >= 344005892 && rawId < 344017424) || (rawId >= 344071428 && rawId < 344082960))
         whichHalfCylinder = 2;
       treeMem.layer = tTopo->pxfDisk(detId_);
       treeMem.side = tTopo->pxfSide(detId_);
       treeMem.half = whichHalfCylinder;
       treeMem.blade = tTopo->pxfBlade(detId_);
       treeMem.panel = tTopo->pxfPanel(detId_);
       treeMem.module = tTopo->pxfModule(detId_);
     } else if (treeMem.subDetId == StripSubdetector::TIB) {
       unsigned int whichHalfShell(1), rawId(detId_.rawId());  //DetId does not kmow about halfShells in TIB
       if ((rawId >= 369120484 && rawId < 369120688) || (rawId >= 369121540 && rawId < 369121776) ||
           (rawId >= 369136932 && rawId < 369137200) || (rawId >= 369137988 && rawId < 369138288) ||
           (rawId >= 369153396 && rawId < 369153744) || (rawId >= 369154436 && rawId < 369154800) ||
           (rawId >= 369169844 && rawId < 369170256) || (rawId >= 369170900 && rawId < 369171344) ||
           (rawId >= 369124580 && rawId < 369124784) || (rawId >= 369125636 && rawId < 369125872) ||
           (rawId >= 369141028 && rawId < 369141296) || (rawId >= 369142084 && rawId < 369142384) ||
           (rawId >= 369157492 && rawId < 369157840) || (rawId >= 369158532 && rawId < 369158896) ||
           (rawId >= 369173940 && rawId < 369174352) || (rawId >= 369174996 && rawId < 369175440))
         whichHalfShell = 2;
       treeMem.layer = tTopo->tibLayer(detId_);
       treeMem.side = tTopo->tibStringInfo(detId_)[0];
       treeMem.half = whichHalfShell;
       treeMem.rod = tTopo->tibStringInfo(detId_)[2];
       treeMem.outerInner = tTopo->tibStringInfo(detId_)[1];
       treeMem.module = tTopo->tibModule(detId_);
       treeMem.isStereo = tTopo->tibStereo(detId_);
       treeMem.isDoubleSide = tTopo->tibIsDoubleSide(detId_);
     } else if (treeMem.subDetId == StripSubdetector::TID) {
       treeMem.layer = tTopo->tidWheel(detId_);
       treeMem.side = tTopo->tidSide(detId_);
       treeMem.ring = tTopo->tidRing(detId_);
       treeMem.outerInner = tTopo->tidModuleInfo(detId_)[0];
       treeMem.module = tTopo->tidModuleInfo(detId_)[1];
       treeMem.isStereo = tTopo->tidStereo(detId_);
       treeMem.isDoubleSide = tTopo->tidIsDoubleSide(detId_);
     } else if (treeMem.subDetId == StripSubdetector::TOB) {
       treeMem.layer = tTopo->tobLayer(detId_);
       treeMem.side = tTopo->tobRodInfo(detId_)[0];
       treeMem.rod = tTopo->tobRodInfo(detId_)[1];
       treeMem.module = tTopo->tobModule(detId_);
       treeMem.isStereo = tTopo->tobStereo(detId_);
       treeMem.isDoubleSide = tTopo->tobIsDoubleSide(detId_);
     } else if (treeMem.subDetId == StripSubdetector::TEC) {
       treeMem.layer = tTopo->tecWheel(detId_);
       treeMem.side = tTopo->tecSide(detId_);
       treeMem.ring = tTopo->tecRing(detId_);
       treeMem.petal = tTopo->tecPetalInfo(detId_)[1];
       treeMem.outerInner = tTopo->tecPetalInfo(detId_)[0];
       treeMem.module = tTopo->tecModule(detId_);
       treeMem.isStereo = tTopo->tecStereo(detId_);
       treeMem.isDoubleSide = tTopo->tecIsDoubleSide(detId_);
     }
 
     //variables concerning the tracker geometry
     const Surface::PositionType& gPModule = tkgeom.idToDet(detId_)->position();
     treeMem.posPhi = gPModule.phi();
     treeMem.posEta = gPModule.eta();
     treeMem.posR = gPModule.perp();
     treeMem.posX = gPModule.x();
     treeMem.posY = gPModule.y();
     treeMem.posZ = gPModule.z();
 
     const Surface& surface = tkgeom.idToDet(detId_)->surface();
 
     //global Orientation of local coordinate system of dets/detUnits
     LocalPoint lUDirection(1., 0., 0.), lVDirection(0., 1., 0.), lWDirection(0., 0., 1.);
     GlobalPoint gUDirection = surface.toGlobal(lUDirection), gVDirection = surface.toGlobal(lVDirection),
                 gWDirection = surface.toGlobal(lWDirection);
     double dR(999.), dPhi(999.), dZ(999.);
     if (treeMem.subDetId == PixelSubdetector::PixelBarrel || treeMem.subDetId == StripSubdetector::TIB ||
         treeMem.subDetId == StripSubdetector::TOB) {
       dR = gWDirection.perp() - gPModule.perp();
       dPhi = deltaPhi(gUDirection.barePhi(), gPModule.barePhi());
       dZ = gVDirection.z() - gPModule.z();
       if (dZ >= 0.)
         treeMem.rOrZDirection = 1;
       else
         treeMem.rOrZDirection = -1;
     } else if (treeMem.subDetId == PixelSubdetector::PixelEndcap) {
       dR = gUDirection.perp() - gPModule.perp();
       dPhi = deltaPhi(gVDirection.barePhi(), gPModule.barePhi());
       dZ = gWDirection.z() - gPModule.z();
       if (dR >= 0.)
         treeMem.rOrZDirection = 1;
       else
         treeMem.rOrZDirection = -1;
     } else if (treeMem.subDetId == StripSubdetector::TID || treeMem.subDetId == StripSubdetector::TEC) {
       dR = gVDirection.perp() - gPModule.perp();
       dPhi = deltaPhi(gUDirection.barePhi(), gPModule.barePhi());
       dZ = gWDirection.z() - gPModule.z();
       if (dR >= 0.)
         treeMem.rOrZDirection = 1;
       else
         treeMem.rOrZDirection = -1;
     }
     if (dR >= 0.)
       treeMem.rDirection = 1;
     else
       treeMem.rDirection = -1;
     if (dPhi >= 0.)
       treeMem.phiDirection = 1;
     else
       treeMem.phiDirection = -1;
     if (dZ >= 0.)
       treeMem.zDirection = 1;
     else
       treeMem.zDirection = -1;
   }
 }

◆ summarizeBinInContainer() [1/2]

void TrackerOfflineValidation::summarizeBinInContainer	(	int	bin,
		SummaryContainer &	targetContainer,
		SummaryContainer &	sourceContainer
	)

private

Definition at line 1115 of file TrackerOfflineValidation.cc.

References newFWLiteAna::bin, summaryBins_, TrackerOfflineValidation::SummaryContainer::summaryNormXResiduals_, TrackerOfflineValidation::SummaryContainer::summaryNormYResiduals_, TrackerOfflineValidation::SummaryContainer::summaryXResiduals_, TrackerOfflineValidation::SummaryContainer::summaryYResiduals_, TrackerOfflineValidation::SummaryContainer::sumNormXResiduals_, TrackerOfflineValidation::SummaryContainer::sumNormYResiduals_, TrackerOfflineValidation::SummaryContainer::sumXResiduals_, and TrackerOfflineValidation::SummaryContainer::sumYResiduals_.

Referenced by bookSummaryHists(), and prepareSummaryHists().

                                                                                           {
   summaryBins_.emplace_back(bin, targetContainer.summaryXResiduals_, sourceContainer.sumXResiduals_);
   summaryBins_.emplace_back(bin, targetContainer.summaryNormXResiduals_, sourceContainer.sumNormXResiduals_);
   // If no y-residual hists, just returns:
   summaryBins_.emplace_back(bin, targetContainer.summaryYResiduals_, sourceContainer.sumYResiduals_);
   summaryBins_.emplace_back(bin, targetContainer.summaryNormYResiduals_, sourceContainer.sumNormYResiduals_);
 }

◆ summarizeBinInContainer() [2/2]

void TrackerOfflineValidation::summarizeBinInContainer	(	int	bin,
		uint32_t	subDetId,
		SummaryContainer &	targetContainer,
		ModuleHistos &	sourceContainer
	)

private

Definition at line 1125 of file TrackerOfflineValidation.cc.

                                                                                       {
   // takes two summary Containers and sets summaryBins for all histograms
   summaryBins_.emplace_back(bin, targetContainer.summaryXResiduals_, sourceContainer.ResXprimeHisto);
   summaryBins_.emplace_back(bin, targetContainer.summaryNormXResiduals_, sourceContainer.NormResXprimeHisto);
   if (this->isPixel(subDetId) || stripYResiduals_) {
     summaryBins_.emplace_back(bin, targetContainer.summaryYResiduals_, sourceContainer.ResYprimeHisto);
     summaryBins_.emplace_back(bin, targetContainer.summaryNormYResiduals_, sourceContainer.NormResYprimeHisto);
   }
 }