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

Inheritance diagram for TrackerOfflineValidation:

Classes
struct	DirectoryWrapper

struct	ModuleHistos

struct	SummaryContainer

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

Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	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::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

	~EDAnalyzer () 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

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::vector< ModuleDescription const * > &modules, 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

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

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 bool	dqmMode_

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 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
Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

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 ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

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<typename ESProduct , Transition Tr = Transition::Event>
auto	esConsumes (eventsetup::EventSetupRecordKey const &, ESInputTag const &tag)

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)

Detailed Description

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

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

Definition at line 79 of file TrackerOfflineValidation.cc.

Member Enumeration Documentation

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 ( const edm::ParameterSet & iConfig )

explicit

Definition at line 382 of file TrackerOfflineValidation.cc.

   : parSet_(iConfig), bareTkGeomPtr_(nullptr), 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")),
     nTracks_(0),
     maxTracks_(parSet_.getParameter<unsigned long long>("maxTracks")),
     avalidator_(iConfig, consumesCollector())
 {
 }

TrackerOfflineValidation::~TrackerOfflineValidation ( )

override

Definition at line 399 of file TrackerOfflineValidation.cc.

References 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

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

overrideprivate

Definition at line 1011 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 (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);  
 }

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

private

Definition at line 637 of file TrackerOfflineValidation.cc.

References Alignable::alignableObjectId(), alignableTracker_, bookHists(), makeMuonMisalignmentScenario::components, Alignable::components(), compare_using_db::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);
     }
   }
 }

void TrackerOfflineValidation::bookGlobalHists ( DirectoryWrapper & tfd )

private

Definition at line 465 of file TrackerOfflineValidation.cc.

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

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)); 
 
 }

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

private

Definition at line 665 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
       }
     }
   }
 }

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

private

Definition at line 1361 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;
 }

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

private

Definition at line 823 of file TrackerOfflineValidation.cc.

References 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);
 }

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

private

Definition at line 834 of file TrackerOfflineValidation.cc.

References 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);
 }

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 847 of file TrackerOfflineValidation.cc.

References 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);
 }

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

privatevirtual

Definition at line 416 of file TrackerOfflineValidation.cc.

References alignableTracker_, bareTkGeomPtr_, bookDirHists(), bookGlobalHists(), TrackerGeometry::detIds(), TrackerGeometry::detUnitIds(), dqmMode_, edm::EventSetup::get(), moduleDirectory_, mPxbResiduals_, mPxeResiduals_, mTecResiduals_, mTibResiduals_, mTidResiduals_, mTobResiduals_, prepareSummaryHists(), edm::ESHandle< T >::product(), setUpTreeMembers(), AlCaHLTBitMon_QueryRunRegistry::string, and tkGeom_.

Referenced by analyze().

 {
   es.get<TrackerDigiGeometryRecord>().get( tkGeom_ );
   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
     edm::ESHandle<TrackerTopology> tTopoHandle;
     es.get<TrackerTopologyRcd>().get(tTopoHandle);
     const TrackerTopology* const tTopo = tTopoHandle.product();
 
     // 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;
 }

void TrackerOfflineValidation::collateSummaryHists ( )

private

Definition at line 1341 of file TrackerOfflineValidation.cc.

References fitResiduals(), setSummaryBin(), sumHistStructure_, summaryBins_, and toFit_.

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);
 }

void TrackerOfflineValidation::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 1249 of file TrackerOfflineValidation.cc.

References collateSummaryHists(), dqmMode_, fillTree(), GetIndex(), TFileService::make(), 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;
   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;
 }

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

private

Definition at line 1689 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();
   }
 }

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

private

Definition at line 1813 of file TrackerOfflineValidation.cc.

References MillePedeFileConverter_cfg::e, patCandidates_cff::func, SiStripPI::mean, and cms::Exception::what().

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;
 }

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

private

Definition at line 1543 of file TrackerOfflineValidation.cc.

References 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);
 }

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

private

Definition at line 890 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");     
 }

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

private

Definition at line 982 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];
   }
 }

template<class OBJECT_TYPE >

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

private

Definition at line 323 of file TrackerOfflineValidation.cc.

References dataset::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;
 }

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

private

Definition at line 1850 of file TrackerOfflineValidation.cc.

References DEFINE_FWK_MODULE, pfDeepBoostedJetPreprocessParams_cfi::median, pileupCalc::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;
 
 }

bool TrackerOfflineValidation::isBarrel ( uint32_t subDetId )

private

Definition at line 859 of file TrackerOfflineValidation.cc.

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

Referenced by bookHists().

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

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

private

Definition at line 882 of file TrackerOfflineValidation.cc.

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

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

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

bool TrackerOfflineValidation::isEndCap ( uint32_t subDetId )

private

Definition at line 867 of file TrackerOfflineValidation.cc.

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

Referenced by bookHists().

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

bool TrackerOfflineValidation::isPixel ( uint32_t subDetId )

private

Definition at line 875 of file TrackerOfflineValidation.cc.

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

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

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

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

private

Definition at line 1286 of file TrackerOfflineValidation.cc.

References Alignable::alignableObjectId(), alignableTracker_, bookSummaryHists(), makeMuonMisalignmentScenario::components, Alignable::components(), compare_using_db::dirname, dqmMode_, f, isDetOrDetUnit(), LogDebug, moduleDirectory_, gen::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;
     }
   }
 }

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

private

Definition at line 943 of file TrackerOfflineValidation.cc.

References 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;
 }

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

private

Definition at line 1573 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;
   }
 }

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

private

Definition at line 955 of file TrackerOfflineValidation.cc.

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_);
 }

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

private

Definition at line 967 of file TrackerOfflineValidation.cc.

References isPixel(), TrackerOfflineValidation::ModuleHistos::NormResXprimeHisto, TrackerOfflineValidation::ModuleHistos::NormResYprimeHisto, TrackerOfflineValidation::ModuleHistos::ResXprimeHisto, TrackerOfflineValidation::ModuleHistos::ResYprimeHisto, stripYResiduals_, summaryBins_, TrackerOfflineValidation::SummaryContainer::summaryNormXResiduals_, TrackerOfflineValidation::SummaryContainer::summaryNormYResiduals_, TrackerOfflineValidation::SummaryContainer::summaryXResiduals_, and TrackerOfflineValidation::SummaryContainer::summaryYResiduals_.

 {
   // 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);
   }
 }