Inheritance diagram for PixelBaryCentreAnalyzer:

Classes
struct	SimplePoint

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

	~PixelBaryCentreAnalyzer () override=default

Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::SharedResources >
	EDAnalyzer ()=default

	EDAnalyzer (const EDAnalyzer &)=delete

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

const EDAnalyzer &	operator= (const EDAnalyzer &)=delete

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const final

Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDAnalyzerBase () override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const *> const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Static Public Attributes
static const unsigned int	nPixelDiscs = 3

static const unsigned int	nPixelLayers = 4

Private Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

void	beginJob () override

void	endJob () override

void	initBC ()

void	initBS ()

Private Attributes
std::vector< std::string >	bcLabels_

std::map< std::string, TTree * >	bcTrees_

GlobalPoint	BPIX_

GlobalPoint	BPIX_DiffFlippedNonFlipped_

GlobalPoint	BPIX_Flipped_

GlobalPoint	BPIX_NonFlipped_

GlobalPoint	BPIXLayer_ [nPixelLayers]

GlobalPoint	BPIXLayer_DiffFlippedNonFlipped_ [nPixelLayers]

GlobalPoint	BPIXLayer_Flipped_ [nPixelLayers]

GlobalPoint	BPIXLayer_NonFlipped_ [nPixelLayers]

GlobalPoint	BS_

std::vector< std::string >	bsLabels_

std::map< std::string, edm::ESGetToken< BeamSpotObjects, BeamSpotObjectsRcd > >	bsTokens_

std::map< std::string, TTree * >	bsTrees_

GlobalPoint	FPIX_

GlobalPoint	FPIX_minus_

GlobalPoint	FPIX_plus_

GlobalPoint	FPIXDisks_minus_ [nPixelDiscs]

GlobalPoint	FPIXDisks_plus_ [nPixelDiscs]

edm::ESGetToken< Alignments, GlobalPositionRcd >	gprToken_

int	ls_

int	phase_

GlobalPoint	PIX_

int	run_

edm::ESGetToken< SiPixelQuality, SiPixelQualityFromDbRcd >	siPixelQualityToken_

edm::Service< TFileService >	tFileService

std::map< std::string, edm::ESGetToken< Alignments, TrackerAlignmentRcd > >	tkAlignTokens_

edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	trackerGeometryToken_

edm::ESGetToken< TrackerTopology, TrackerTopologyRcd >	trackerTopologyToken_

bool	usePixelQuality_

SimplePoint	vBPIX_

SimplePoint	vBPIX_DiffFlippedNonFlipped_

SimplePoint	vBPIX_Flipped_

SimplePoint	vBPIX_NonFlipped_

SimplePoint	vBPIXLayer_ [nPixelLayers]

SimplePoint	vBPIXLayer_DiffFlippedNonFlipped_ [nPixelLayers]

SimplePoint	vBPIXLayer_Flipped_ [nPixelLayers]

SimplePoint	vBPIXLayer_NonFlipped_ [nPixelLayers]

SimplePoint	vBS_

SimplePoint	vFPIX_

SimplePoint	vFPIX_minus_

SimplePoint	vFPIX_plus_

SimplePoint	vFPIXDisks_minus_ [nPixelDiscs]

SimplePoint	vFPIXDisks_plus_ [nPixelDiscs]

SimplePoint	vPIX_

edm::ESWatcher< BeamSpotObjectsRcd >	watcherBS_

edm::ESWatcher< TrackerAlignmentRcd >	watcherTkAlign_

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename 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<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

The analyer works as the following :

Read global tracker position from global tag
Read tracker alignment constants from different ESsource with different labels
Calculate barycentres for different pixel substructures using global tracker position and alignment constants and store them in trees, one for each ESsource label.

Python script plotBaryCentre_VS_BeamSpot.py under script dir is used to plot barycentres from alignment constants used in Prompt-Reco, End-of-Year Rereco and so-called Run-2 (Ultra)Legacy Rereco. Options of the plotting script can be found from the helper in the script.

Date: 2021/01/05

Revision: 1.0

Author: Tongguang Cheng - Beihang University tongg.nosp@m.uang.nosp@m..chen.nosp@m.g@ce.nosp@m.rn.ch

Definition at line 61 of file PixelBaryCentreAnalyzer.cc.

Constructor & Destructor Documentation

◆ PixelBaryCentreAnalyzer()

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

explicit

Definition at line 144 of file PixelBaryCentreAnalyzer.cc.

References bcLabels_, bcTrees_, bsLabels_, bsTokens_, bsTrees_, label, and tkAlignTokens_.

     : usePixelQuality_(iConfig.getUntrackedParameter<bool>("usePixelQuality")),
       bcLabels_(iConfig.getUntrackedParameter<std::vector<std::string>>("tkAlignLabels")),
       bsLabels_(iConfig.getUntrackedParameter<std::vector<std::string>>("beamSpotLabels")),
       trackerGeometryToken_(esConsumes<TrackerGeometry, TrackerDigiGeometryRecord>()),
       trackerTopologyToken_(esConsumes<TrackerTopology, TrackerTopologyRcd>()),
       siPixelQualityToken_(esConsumes<SiPixelQuality, SiPixelQualityFromDbRcd>()),
       gprToken_(esConsumes<Alignments, GlobalPositionRcd>()) {
   for (const auto& label : bcLabels_) {
     bcTrees_[label] = nullptr;
     tkAlignTokens_[label] = esConsumes<Alignments, TrackerAlignmentRcd>(edm::ESInputTag{"", label});
   }
 
   for (const auto& label : bsLabels_) {
     bsTrees_[label] = nullptr;
     bsTokens_[label] = esConsumes<BeamSpotObjects, BeamSpotObjectsRcd>(edm::ESInputTag{"", label});
   }
 
   usesResource("TFileService");
 }

◆ ~PixelBaryCentreAnalyzer()

PixelBaryCentreAnalyzer::~PixelBaryCentreAnalyzer ( )

overridedefault

Member Function Documentation

◆ analyze()

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

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 228 of file PixelBaryCentreAnalyzer.cc.

References bcLabels_, bcTrees_, BPIX_, BPIX_DiffFlippedNonFlipped_, BPIX_Flipped_, BPIX_NonFlipped_, BPIXLayer_, BPIXLayer_DiffFlippedNonFlipped_, BPIXLayer_Flipped_, BPIXLayer_NonFlipped_, BS_, bsLabels_, bsTokens_, bsTrees_, edm::ESWatcher< T >::check(), align::DetectorGlobalPosition(), FPIX_, FPIX_minus_, FPIX_plus_, FPIXDisks_minus_, FPIXDisks_plus_, edm::EventSetup::getData(), gprToken_, PixelEndcapName::halfCylinder(), l1ctLayer2EG_cff::id, iEvent, initBC(), initBS(), SiPixelQuality::IsModuleBad(), TrackerGeometry::isThere(), label, PVValHelper::ladder, pixelTopology::layer, ls_, Alignments::m_align, genParticles_cff::map, GeomDetEnumerators::P1PXB, GeomDetEnumerators::P1PXEC, phase_, PIX_, GeomDetEnumerators::PixelBarrel, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, GeomDetEnumerators::PixelEndcap, TrackerTopology::pxbLadder(), TrackerTopology::pxbLayer(), TrackerTopology::pxfDisk(), TrackerTopology::pxfModule(), TrackerTopology::pxfPanel(), SiPixelPI::quadrant(), DetId::rawId(), relativeConstraints::ring, PixelEndcapName::ringName(), run_, siPixelQualityToken_, DetId::subdetId(), tkAlignTokens_, DetId::Tracker, trackerGeometryToken_, trackerTopologyToken_, AlignTransform::translation(), usePixelQuality_, vBPIX_, vBPIX_DiffFlippedNonFlipped_, vBPIX_Flipped_, vBPIX_NonFlipped_, vBPIXLayer_, vBPIXLayer_DiffFlippedNonFlipped_, vBPIXLayer_Flipped_, vBPIXLayer_NonFlipped_, vBS_, vFPIX_, vFPIX_minus_, vFPIX_plus_, vFPIXDisks_minus_, vFPIXDisks_plus_, vPIX_, watcherBS_, watcherTkAlign_, PV3DBase< T, PVType, FrameType >::x(), BeamSpotObjects::x(), PV3DBase< T, PVType, FrameType >::y(), BeamSpotObjects::y(), PV3DBase< T, PVType, FrameType >::z(), and BeamSpotObjects::z().

                                                                                          {
   bool prepareTkAlign = false;
   bool prepareBS = false;
 
   // ES watcher can noly run once in the same event,
   // otherwise it will turn false whatsoever because the condition doesn't change in the second time call.
   if (watcherTkAlign_.check(iSetup))
     prepareTkAlign = true;
   if (watcherBS_.check(iSetup))
     prepareBS = true;
 
   if (!prepareTkAlign && !prepareBS)
     return;
 
   run_ = iEvent.id().run();
   ls_ = iEvent.id().luminosityBlock();
 
   if (prepareTkAlign) {  // check for new IOV for TKAlign
 
     phase_ = -1;
 
     const TrackerGeometry* tkGeo = &iSetup.getData(trackerGeometryToken_);
     const TrackerTopology* tkTopo = &iSetup.getData(trackerTopologyToken_);
 
     if (tkGeo->isThere(GeomDetEnumerators::PixelBarrel) && tkGeo->isThere(GeomDetEnumerators::PixelEndcap))
       phase_ = 0;
     else if (tkGeo->isThere(GeomDetEnumerators::P1PXB) && tkGeo->isThere(GeomDetEnumerators::P1PXEC))
       phase_ = 1;
 
     // pixel quality
     const SiPixelQuality* badPixelInfo = &iSetup.getData(siPixelQualityToken_);
 
     // Tracker global position
     const Alignments* globalAlignments = &iSetup.getData(gprToken_);
     std::unique_ptr<const Alignments> globalPositions = std::make_unique<Alignments>(*globalAlignments);
     const AlignTransform& globalCoordinates = align::DetectorGlobalPosition(*globalPositions, DetId(DetId::Tracker));
     GlobalVector globalTkPosition(
         globalCoordinates.translation().x(), globalCoordinates.translation().y(), globalCoordinates.translation().z());
 
     // loop over bclabels
     for (const auto& label : bcLabels_) {
       // init tree content
       PixelBaryCentreAnalyzer::initBC();
 
       // Get TkAlign from EventSetup:
       const Alignments* alignments = &iSetup.getData(tkAlignTokens_[label]);
       std::vector<AlignTransform> tkAlignments = alignments->m_align;
 
       // PIX
       GlobalVector barycentre_PIX(0.0, 0.0, 0.0);
       // BPIX
       GlobalVector barycentre_BPIX(0.0, 0.0, 0.0);
       float nmodules_BPIX(0.);
       // FPIX
       GlobalVector barycentre_FPIX(0.0, 0.0, 0.0);
       float nmodules_FPIX(0.);
 
       // Per-layer/ladder barycentre for BPIX
       std::map<int, std::map<int, float>> nmodules_bpix;           // layer-ladder
       std::map<int, std::map<int, GlobalVector>> barycentre_bpix;  // layer-ladder
 
       // Per-disk/ring barycentre for FPIX
       std::map<int, std::map<int, float>> nmodules_fpix;           // disk-ring
       std::map<int, std::map<int, GlobalVector>> barycentre_fpix;  // disk-ring
 
       // Loop over tracker module
       for (const auto& ali : tkAlignments) {
         //DetId
         const DetId& detId = DetId(ali.rawId());
         // remove bad module
         if (usePixelQuality_ && badPixelInfo->IsModuleBad(detId))
           continue;
 
         // alignment for a given module
         GlobalVector ali_translation(ali.translation().x(), ali.translation().y(), ali.translation().z());
 
         int subid = DetId(detId).subdetId();
         // BPIX
         if (subid == PixelSubdetector::PixelBarrel) {
           nmodules_BPIX += 1;
           barycentre_BPIX += ali_translation;
           barycentre_PIX += ali_translation;
 
           int layer = tkTopo->pxbLayer(detId);
           int ladder = tkTopo->pxbLadder(detId);
           nmodules_bpix[layer][ladder] += 1;
           barycentre_bpix[layer][ladder] += ali_translation;
 
         }  // BPIX
 
         // FPIX
         if (subid == PixelSubdetector::PixelEndcap) {
           nmodules_FPIX += 1;
           barycentre_FPIX += ali_translation;
           barycentre_PIX += ali_translation;
 
           int disk = tkTopo->pxfDisk(detId);
           int quadrant = PixelEndcapName(detId, tkTopo, phase_).halfCylinder();
           if (quadrant < 3)
             disk *= -1;
 
           int ring = -9999;
           if (phase_ == 0) {
             ring = 1 + (tkTopo->pxfPanel(detId) + tkTopo->pxfModule(detId.rawId()) > 3);
           } else if (phase_ == 1) {
             ring = PixelEndcapName(detId, tkTopo, phase_).ringName();
           }
 
           nmodules_fpix[disk][ring] += 1;
           barycentre_fpix[disk][ring] += ali_translation;
 
         }  // FPIX
 
       }  // loop over tracker module
 
       //PIX
       float nmodules_PIX = nmodules_BPIX + nmodules_FPIX;
       barycentre_PIX *= (1.0 / nmodules_PIX);
       barycentre_PIX += globalTkPosition;
       PIX_ = GlobalPoint(barycentre_PIX.x(), barycentre_PIX.y(), barycentre_PIX.z());
       vPIX_ = SimplePoint(PIX_);
 
       //BPIX
       barycentre_BPIX *= (1.0 / nmodules_BPIX);
       barycentre_BPIX += globalTkPosition;
       BPIX_ = GlobalPoint(barycentre_BPIX.x(), barycentre_BPIX.y(), barycentre_BPIX.z());
       vBPIX_ = SimplePoint(BPIX_);
       //FPIX
       barycentre_FPIX *= (1.0 / nmodules_FPIX);
       barycentre_FPIX += globalTkPosition;
       FPIX_ = GlobalPoint(barycentre_FPIX.x(), barycentre_FPIX.y(), barycentre_FPIX.z());
       vFPIX_ = SimplePoint(FPIX_);
       // Pixel substructures
 
       // BPix barycentre per-layer/per-ladder
       // assuming each ladder has the same number of modules in the same layer
       // inner =  flipped; outer = non-flipped
       //
       // Phase 0: Outer ladders are odd for layer 1,3 and even for layer 2
       // Phase 1: Outer ladders are odd for layer 4 and even for layer 1,2,3
       //
 
       int nmodules_BPIX_Flipped = 0;
       int nmodules_BPIX_NonFlipped = 0;
       GlobalVector BPIX_Flipped(0.0, 0.0, 0.0);
       GlobalVector BPIX_NonFlipped(0.0, 0.0, 0.0);
 
       // loop over layers
       for (std::map<int, std::map<int, GlobalVector>>::iterator il = barycentre_bpix.begin();
            il != barycentre_bpix.end();
            ++il) {
         int layer = il->first;
 
         int nmodulesLayer = 0;
         int nmodulesLayer_Flipped = 0;
         int nmodulesLayer_NonFlipped = 0;
         GlobalVector BPIXLayer(0.0, 0.0, 0.0);
         GlobalVector BPIXLayer_Flipped(0.0, 0.0, 0.0);
         GlobalVector BPIXLayer_NonFlipped(0.0, 0.0, 0.0);
 
         // loop over ladder
         std::map<int, GlobalVector> barycentreLayer = barycentre_bpix[layer];
         for (std::map<int, GlobalVector>::iterator it = barycentreLayer.begin(); it != barycentreLayer.end(); ++it) {
           int ladder = it->first;
           //BPIXLayerLadder_[layer][ladder] = (1.0/nmodules[layer][ladder])*barycentreLayer[ladder] + globalTkPosition;
 
           nmodulesLayer += nmodules_bpix[layer][ladder];
           BPIXLayer += barycentreLayer[ladder];
 
           // Phase-1
           //
           // Phase 1: Outer ladders are odd for layer 4 and even for layer 1,2,3
           if (phase_ == 1) {
             if (layer != 4) {  // layer 1-3
 
               if (ladder % 2 != 0) {  // odd ladder = outer ladder = unflipped
                 nmodulesLayer_NonFlipped += nmodules_bpix[layer][ladder];
                 BPIXLayer_NonFlipped += barycentreLayer[ladder];
               } else {  // even ladder = inner ladder = flipped
                 nmodulesLayer_Flipped += nmodules_bpix[layer][ladder];
                 BPIXLayer_Flipped += barycentreLayer[ladder];
               }
             } else {  // layer-4
 
               if (ladder % 2 != 0) {  // odd ladder = inner = flipped
                 nmodulesLayer_Flipped += nmodules_bpix[layer][ladder];
                 BPIXLayer_Flipped += barycentreLayer[ladder];
               } else {  //even ladder = outer ladder  = unflipped
                 nmodulesLayer_NonFlipped += nmodules_bpix[layer][ladder];
                 BPIXLayer_NonFlipped += barycentreLayer[ladder];
               }
             }
 
           }  // phase-1
 
           // Phase-0
           //
           // Phase 0: Outer ladders are odd for layer 1,3 and even for layer 2
           if (phase_ == 0) {
             if (layer == 2) {  // layer-2
 
               if (ladder % 2 != 0) {  // odd ladder = inner = flipped
                 nmodulesLayer_Flipped += nmodules_bpix[layer][ladder];
                 BPIXLayer_Flipped += barycentreLayer[ladder];
               } else {
                 nmodulesLayer_NonFlipped += nmodules_bpix[layer][ladder];
                 BPIXLayer_NonFlipped += barycentreLayer[ladder];
               }
             } else {  // layer-1,3
 
               if (ladder % 2 == 0) {  // even ladder = inner = flipped
                 nmodulesLayer_Flipped += nmodules_bpix[layer][ladder];
                 BPIXLayer_Flipped += barycentreLayer[ladder];
               } else {  // odd ladder = outer = non-flipped
                 nmodulesLayer_NonFlipped += nmodules_bpix[layer][ladder];
                 BPIXLayer_NonFlipped += barycentreLayer[ladder];
               }
             }
 
           }  // phase-0
 
         }  //loop over ladders
 
         // total BPIX flipped/non-flipped
         BPIX_Flipped += BPIXLayer_Flipped;
         BPIX_NonFlipped += BPIXLayer_NonFlipped;
         nmodules_BPIX_Flipped += nmodulesLayer_Flipped;
         nmodules_BPIX_NonFlipped += nmodulesLayer_NonFlipped;
 
         //BPIX per-layer
         BPIXLayer *= (1.0 / nmodulesLayer);
         BPIXLayer += globalTkPosition;
         BPIXLayer_Flipped *= (1.0 / nmodulesLayer_Flipped);
         BPIXLayer_Flipped += globalTkPosition;
         BPIXLayer_NonFlipped *= (1.0 / nmodulesLayer_NonFlipped);
         BPIXLayer_NonFlipped += globalTkPosition;
 
         BPIXLayer_[layer - 1] = GlobalPoint(BPIXLayer.x(), BPIXLayer.y(), BPIXLayer.z());
         vBPIXLayer_[layer - 1] = SimplePoint(BPIXLayer_[layer - 1]);
         BPIXLayer_Flipped_[layer - 1] =
             GlobalPoint(BPIXLayer_Flipped.x(), BPIXLayer_Flipped.y(), BPIXLayer_Flipped.z());
         vBPIXLayer_Flipped_[layer - 1] = SimplePoint(BPIXLayer_Flipped_[layer - 1]);
         BPIXLayer_NonFlipped_[layer - 1] =
             GlobalPoint(BPIXLayer_NonFlipped.x(), BPIXLayer_NonFlipped.y(), BPIXLayer_NonFlipped.z());
         vBPIXLayer_NonFlipped_[layer - 1] = SimplePoint(BPIXLayer_NonFlipped_[layer - 1]);
         BPIXLayer_DiffFlippedNonFlipped_[layer - 1] = GlobalPoint(BPIXLayer_Flipped.x() - BPIXLayer_NonFlipped.x(),
                                                                   BPIXLayer_Flipped.y() - BPIXLayer_NonFlipped.y(),
                                                                   BPIXLayer_Flipped.z() - BPIXLayer_NonFlipped.z());
         vBPIXLayer_DiffFlippedNonFlipped_[layer - 1] = SimplePoint(BPIXLayer_DiffFlippedNonFlipped_[layer - 1]);
 
       }  // loop over layers
 
       BPIX_Flipped *= (1.0 / nmodules_BPIX_Flipped);
       BPIX_Flipped += globalTkPosition;
       BPIX_Flipped_ = GlobalPoint(BPIX_Flipped.x(), BPIX_Flipped.y(), BPIX_Flipped.z());
       vBPIX_Flipped_ = SimplePoint(BPIX_Flipped_);
       BPIX_NonFlipped *= (1.0 / nmodules_BPIX_NonFlipped);
       BPIX_NonFlipped += globalTkPosition;
       BPIX_NonFlipped_ = GlobalPoint(BPIX_NonFlipped.x(), BPIX_NonFlipped.y(), BPIX_NonFlipped.z());
       vBPIX_NonFlipped_ = SimplePoint(BPIX_NonFlipped_);
       BPIX_DiffFlippedNonFlipped_ = GlobalPoint(BPIX_Flipped.x() - BPIX_NonFlipped.x(),
                                                 BPIX_Flipped.y() - BPIX_NonFlipped.y(),
                                                 BPIX_Flipped.z() - BPIX_NonFlipped.z());
       vBPIX_DiffFlippedNonFlipped_ = SimplePoint(BPIX_DiffFlippedNonFlipped_);
 
       // FPIX substructures per-(signed)disk/per-ring
       int nmodules_FPIX_plus = 0;
       int nmodules_FPIX_minus = 0;
       GlobalVector FPIX_plus(0.0, 0.0, 0.0);
       GlobalVector FPIX_minus(0.0, 0.0, 0.0);
       // loop over disks
       for (std::map<int, std::map<int, GlobalVector>>::iterator id = barycentre_fpix.begin();
            id != barycentre_fpix.end();
            ++id) {
         int disk = id->first;
 
         int nmodulesDisk = 0;
         GlobalVector FPIXDisk(0.0, 0.0, 0.0);
 
         std::map<int, GlobalVector> baryCentreDisk = id->second;
         for (std::map<int, GlobalVector>::iterator ir = baryCentreDisk.begin(); ir != baryCentreDisk.end();
              ++ir) {  // loop over rings
           int ring = ir->first;
           nmodulesDisk += nmodules_fpix[disk][ring];
           FPIXDisk += ir->second;
           if (disk > 0) {
             nmodules_FPIX_plus += nmodules_fpix[disk][ring];
             FPIX_plus += ir->second;
           }
           if (disk < 0) {
             nmodules_FPIX_minus += nmodules_fpix[disk][ring];
             FPIX_minus += ir->second;
           }
 
         }  // loop over rings
 
         FPIXDisk *= (1.0 / nmodulesDisk);
         FPIXDisk += globalTkPosition;
 
         if (disk > 0) {
           FPIXDisks_plus_[disk - 1] = GlobalPoint(FPIXDisk.x(), FPIXDisk.y(), FPIXDisk.z());
           vFPIXDisks_plus_[disk - 1] = SimplePoint(FPIXDisks_plus_[disk - 1]);
         }
         if (disk < 0) {
           FPIXDisks_minus_[-disk - 1] = GlobalPoint(FPIXDisk.x(), FPIXDisk.y(), FPIXDisk.z());
           vFPIXDisks_minus_[-disk - 1] = SimplePoint(FPIXDisks_minus_[-disk - 1]);
         }
       }  // loop over disks
 
       FPIX_plus *= (1.0 / nmodules_FPIX_plus);
       FPIX_plus += globalTkPosition;
       FPIX_plus_ = GlobalPoint(FPIX_plus.x(), FPIX_plus.y(), FPIX_plus.z());
       vFPIX_plus_ = SimplePoint(FPIX_plus_);
       FPIX_minus *= (1.0 / nmodules_FPIX_minus);
       FPIX_minus += globalTkPosition;
       FPIX_minus_ = GlobalPoint(FPIX_minus.x(), FPIX_minus.y(), FPIX_minus.z());
       vFPIX_minus_ = SimplePoint(FPIX_minus_);
 
       bcTrees_[label]->Fill();
 
     }  // bcLabels_
 
   }  // check for new IOV for TKAlign
 
   // beamspot
   if (prepareBS) {
     // loop over bsLabels_
     for (const auto& label : bsLabels_) {
       // init bstree content
       PixelBaryCentreAnalyzer::initBS();
 
       // Get BeamSpot from EventSetup
       const BeamSpotObjects* mybeamspot = &iSetup.getData(bsTokens_[label]);
 
       BS_ = GlobalPoint(mybeamspot->x(), mybeamspot->y(), mybeamspot->z());
       vBS_ = SimplePoint(BS_);
 
       bsTrees_[label]->Fill();
     }  // bsLabels_
 
   }  // check for new IOV for BS
 }

◆ beginJob()

void PixelBaryCentreAnalyzer::beginJob ( )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 572 of file PixelBaryCentreAnalyzer.cc.

References bcLabels_, bcTrees_, bsLabels_, bsTrees_, mps_fire::i, label, pixelTopology::layer, ls_, TFileService::make(), nPixelDiscs, nPixelLayers, run_, AlCaHLTBitMon_QueryRunRegistry::string, tFileService, vBPIX_, vBPIX_DiffFlippedNonFlipped_, vBPIX_Flipped_, vBPIX_NonFlipped_, vBPIXLayer_, vBPIXLayer_DiffFlippedNonFlipped_, vBPIXLayer_Flipped_, vBPIXLayer_NonFlipped_, vBS_, vFPIX_, vFPIX_minus_, vFPIX_plus_, vFPIXDisks_minus_, vFPIXDisks_plus_, and vPIX_.

                                        {
   // init bc bs trees
   for (const auto& label : bsLabels_) {
     std::string treeName = "BeamSpot";
     if (!label.empty())
       treeName = "BeamSpot_";
     treeName += label;
 
     bsTrees_[label] = tFileService->make<TTree>(TString(treeName), "PixelBarycentre analyzer ntuple");
 
     bsTrees_[label]->Branch("run", &run_, "run/I");
     bsTrees_[label]->Branch("ls", &ls_, "ls/I");
 
     bsTrees_[label]->Branch("BS", &vBS_, "x/F:y/F:z/F");
 
   }  // bsLabels_
 
   for (const auto& label : bcLabels_) {
     std::string treeName = "PixelBarycentre";
     if (!label.empty())
       treeName = "PixelBarycentre_";
     treeName += label;
     bcTrees_[label] = tFileService->make<TTree>(TString(treeName), "PixelBarycentre analyzer ntuple");
 
     bcTrees_[label]->Branch("run", &run_, "run/I");
     bcTrees_[label]->Branch("ls", &ls_, "ls/I");
 
     bcTrees_[label]->Branch("PIX", &vPIX_, "x/F:y/F:z/F");
 
     bcTrees_[label]->Branch("BPIX", &vBPIX_, "x/F:y/F:z/F");
     bcTrees_[label]->Branch("BPIX_Flipped", &vBPIX_Flipped_, "x/F:y/F:z/F");
     bcTrees_[label]->Branch("BPIX_NonFlipped", &vBPIX_NonFlipped_, "x/F:y/F:z/F");
     bcTrees_[label]->Branch("BPIX_DiffFlippedNonFlipped", &vBPIX_DiffFlippedNonFlipped_, "x/F:y/F:z/F");
 
     bcTrees_[label]->Branch("FPIX", &vFPIX_, "x/F:y/F:z/F");
     bcTrees_[label]->Branch("FPIX_plus", &vFPIX_plus_, "x/F:y/F:z/F");
     bcTrees_[label]->Branch("FPIX_minus", &vFPIX_minus_, "x/F:y/F:z/F");
 
     //per-layer
     for (unsigned int i = 0; i < nPixelLayers; i++) {
       TString structure = "BPIXLYR";
       int layer = i + 1;
       structure += layer;
 
       bcTrees_[label]->Branch(structure, &vBPIXLayer_[i], "x/F:y/F:z/F");
       bcTrees_[label]->Branch(structure + "_Flipped", &vBPIXLayer_Flipped_[i], "x/F:y/F:z/F");
       bcTrees_[label]->Branch(structure + "_NonFlipped", &vBPIXLayer_NonFlipped_[i], "x/F:y/F:z/F");
       bcTrees_[label]->Branch(
           structure + "_DiffFlippedNonFlipped", &vBPIXLayer_DiffFlippedNonFlipped_[i], "x/F:y/F:z/F");
     }
 
     //per-disk/ring
     for (unsigned int i = 0; i < nPixelDiscs; i++) {
       TString structure = "FPIXDisk_plus";
       int disk = i + 1;
       structure += disk;
       bcTrees_[label]->Branch(structure, &vFPIXDisks_plus_[i], "x/F:y/F:z/F");
 
       structure = "FPIXDisk_minus";
       structure += disk;
       bcTrees_[label]->Branch(structure, &vFPIXDisks_minus_[i], "x/F:y/F:z/F");
     }
 
   }  // bcLabels_
 }

◆ endJob()

void PixelBaryCentreAnalyzer::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 639 of file PixelBaryCentreAnalyzer.cc.

References bcLabels_, bcTrees_, bsLabels_, and bsTrees_.

Referenced by o2olib.O2ORunMgr::executeJob().

                                      {
   bcLabels_.clear();
   bsLabels_.clear();
 
   bcTrees_.clear();
   bsTrees_.clear();
 }

◆ fillDescriptions()

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

static

Definition at line 648 of file PixelBaryCentreAnalyzer.cc.

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

                                                                                          {
   edm::ParameterSetDescription desc;
   desc.setComment("Validates alignment payloads by providing the position of the pixel barycenter positions");
   desc.addUntracked<bool>("usePixelQuality", false);
   desc.addUntracked<std::vector<std::string>>("tkAlignLabels", {});
   desc.addUntracked<std::vector<std::string>>("beamSpotLabels", {});
   descriptions.addWithDefaultLabel(desc);
 }

◆ initBC()

void PixelBaryCentreAnalyzer::initBC ( )

private

Definition at line 176 of file PixelBaryCentreAnalyzer.cc.

References BPIX_, BPIX_DiffFlippedNonFlipped_, BPIX_Flipped_, BPIX_NonFlipped_, BPIXLayer_, BPIXLayer_DiffFlippedNonFlipped_, BPIXLayer_Flipped_, BPIXLayer_NonFlipped_, FPIX_, FPIX_minus_, FPIX_plus_, FPIXDisks_minus_, FPIXDisks_plus_, mps_fire::i, nPixelDiscs, nPixelLayers, PIX_, vBPIX_, vBPIX_DiffFlippedNonFlipped_, vBPIX_Flipped_, vBPIX_NonFlipped_, vBPIXLayer_, vBPIXLayer_DiffFlippedNonFlipped_, vBPIXLayer_Flipped_, vBPIXLayer_NonFlipped_, vFPIX_, vFPIX_minus_, vFPIX_plus_, vFPIXDisks_minus_, vFPIXDisks_plus_, and vPIX_.

Referenced by analyze().

                                      {
   // init to large number (unreasonable number) not zero
   double dummy_float = 999999.0;
 
   PIX_ = GlobalPoint(dummy_float, dummy_float, dummy_float);
   BPIX_ = GlobalPoint(dummy_float, dummy_float, dummy_float);
   FPIX_ = GlobalPoint(dummy_float, dummy_float, dummy_float);
 
   BPIX_Flipped_ = GlobalPoint(dummy_float, dummy_float, dummy_float);
   BPIX_NonFlipped_ = GlobalPoint(dummy_float, dummy_float, dummy_float);
   BPIX_DiffFlippedNonFlipped_ = GlobalPoint(dummy_float, dummy_float, dummy_float);
 
   FPIX_plus_ = GlobalPoint(dummy_float, dummy_float, dummy_float);
   FPIX_minus_ = GlobalPoint(dummy_float, dummy_float, dummy_float);
 
   for (unsigned int i = 0; i < nPixelLayers; i++) {
     BPIXLayer_[i] = GlobalPoint(dummy_float, dummy_float, dummy_float);
     BPIXLayer_Flipped_[i] = GlobalPoint(dummy_float, dummy_float, dummy_float);
     BPIXLayer_NonFlipped_[i] = GlobalPoint(dummy_float, dummy_float, dummy_float);
     BPIXLayer_DiffFlippedNonFlipped_[i] = GlobalPoint(dummy_float, dummy_float, dummy_float);
   }
 
   for (unsigned int i = 0; i < nPixelDiscs; i++) {
     FPIXDisks_plus_[i] = GlobalPoint(dummy_float, dummy_float, dummy_float);
     FPIXDisks_minus_[i] = GlobalPoint(dummy_float, dummy_float, dummy_float);
   }
 
   vPIX_ = SimplePoint(PIX_);
   vBPIX_ = SimplePoint(BPIX_);
   vFPIX_ = SimplePoint(FPIX_);
 
   vBPIX_Flipped_ = SimplePoint(BPIX_Flipped_);
   vBPIX_NonFlipped_ = SimplePoint(BPIX_NonFlipped_);
   vBPIX_DiffFlippedNonFlipped_ = SimplePoint(BPIX_DiffFlippedNonFlipped_);
 
   vFPIX_plus_ = SimplePoint(FPIX_plus_);
   vFPIX_minus_ = SimplePoint(FPIX_minus_);
 
   for (unsigned int i = 0; i < nPixelLayers; i++) {
     vBPIXLayer_[i] = SimplePoint(BPIXLayer_[i]);
     vBPIXLayer_Flipped_[i] = SimplePoint(BPIXLayer_Flipped_[i]);
     vBPIXLayer_NonFlipped_[i] = SimplePoint(BPIXLayer_NonFlipped_[i]);
     vBPIXLayer_DiffFlippedNonFlipped_[i] = SimplePoint(BPIXLayer_DiffFlippedNonFlipped_[i]);
   }
 
   for (unsigned int i = 0; i < nPixelDiscs; i++) {
     vFPIXDisks_plus_[i] = SimplePoint(FPIXDisks_plus_[i]);
     vFPIXDisks_minus_[i] = SimplePoint(FPIXDisks_minus_[i]);
   }
 }

◆ initBS()

void PixelBaryCentreAnalyzer::initBS ( )

private

Definition at line 169 of file PixelBaryCentreAnalyzer.cc.

References BS_, and vBS_.

Referenced by analyze().

                                      {
   double dummy_float = 999999.0;
 
   BS_ = GlobalPoint(dummy_float, dummy_float, dummy_float);
   vBS_ = SimplePoint(BS_);
 }