#include <Alignment/APEEstimation/src/ApeTreeCreateDefault.cc>

Inheritance diagram for ApeTreeCreateDefault:

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

	~ApeTreeCreateDefault () override

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

	EDConsumerBase (EDConsumerBase const &)=delete

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 &	operator= (EDConsumerBase &&)=default

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

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)

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

void	beginJob () override

bool	checkIntervalsForSectors (const unsigned int sectorCounter, const std::vector< double > &) const

bool	checkModuleBools (const bool, const std::vector< unsigned int > &) const

bool	checkModuleDirections (const int, const std::vector< int > &) const

bool	checkModuleIds (const unsigned int, const std::vector< unsigned int > &) const

bool	checkModulePositions (const float, const std::vector< double > &) const

void	endJob () override

void	sectorBuilder ()

Private Attributes
const edm::ESGetToken< AlignmentErrorsExtended, TrackerAlignmentErrorExtendedRcd >	alignmentErrorToken_

std::map< unsigned int, TrackerSectorStruct >	m_tkSector_

std::map< unsigned int, ReducedTrackerTreeVariables >	m_tkTreeVar_

unsigned int	noSectors

const std::string	resultFile_

const std::vector< edm::ParameterSet >	sectors_

const std::string	trackerTreeFile_

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
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

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

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

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

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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

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

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

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

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

Detailed Description

Description: [one line class summary]

Implementation: [Notes on implementation]

Definition at line 63 of file ApeTreeCreateDefault.cc.

Constructor & Destructor Documentation

◆ ApeTreeCreateDefault()

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

explicit

Definition at line 104 of file ApeTreeCreateDefault.cc.

     : alignmentErrorToken_(esConsumes()),
       resultFile_(iConfig.getParameter<std::string>("resultFile")),
       trackerTreeFile_(iConfig.getParameter<std::string>("trackerTreeFile")),
       sectors_(iConfig.getParameter<std::vector<edm::ParameterSet>>("sectors")) {}

◆ ~ApeTreeCreateDefault()

ApeTreeCreateDefault::~ApeTreeCreateDefault ( )

override

Definition at line 110 of file ApeTreeCreateDefault.cc.

110 {}

Member Function Documentation

◆ analyze()

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

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 399 of file ApeTreeCreateDefault.cc.

                                                                                       {
   // Same procedure as in ApeEstimatorSummary.cc minus reading of baseline tree
  
   // Load APEs from the GT and write them to root files similar to the ones from calculateAPE()
   const AlignmentErrorsExtended* alignmentErrors = &iSetup.getData(alignmentErrorToken_);
  
   // Set up root file for default APE values
   const std::string defaultFileName(resultFile_);
   TFile* defaultFile = new TFile(defaultFileName.c_str(), "RECREATE");
  
   // Naming in the root files has to be iterTreeX to be consistent for the plotting tool
   TTree* defaultTreeX(nullptr);
   TTree* defaultTreeY(nullptr);
   defaultFile->GetObject("iterTreeX;1", defaultTreeX);
   defaultFile->GetObject("iterTreeY;1", defaultTreeY);
   // The same for TTree containing the names of the sectors (no additional check, since always handled exactly as defaultTree)
   TTree* sectorNameTree(nullptr);
   defaultFile->GetObject("nameTree;1", sectorNameTree);
  
   edm::LogInfo("DefaultAPETree") << "APE Tree is being created";
   defaultTreeX = new TTree("iterTreeX", "Tree for default APE x values from GT");
   defaultTreeY = new TTree("iterTreeY", "Tree for default APE y values from GT");
   sectorNameTree = new TTree("nameTree", "Tree with names of sectors");
  
   // Assign the information stored in the trees to arrays
   std::vector<double*> a_defaultSectorX;
   std::vector<double*> a_defaultSectorY;
  
   std::vector<std::string*> a_sectorName;
   for (auto const& i_sector : m_tkSector_) {
     const unsigned int iSector(i_sector.first);
     const bool pixelSector(i_sector.second.isPixel);
  
     a_defaultSectorX.push_back(new double(-99.));
     a_defaultSectorY.push_back(new double(-99.));
     a_sectorName.push_back(new std::string(i_sector.second.name));
  
     std::stringstream ss_sector;
     std::stringstream ss_sectorSuffixed;
     ss_sector << "Ape_Sector_" << iSector;
  
     ss_sectorSuffixed << ss_sector.str() << "/D";
     defaultTreeX->Branch(ss_sector.str().c_str(), &(*a_defaultSectorX[iSector - 1]), ss_sectorSuffixed.str().c_str());
  
     if (pixelSector) {
       defaultTreeY->Branch(ss_sector.str().c_str(), &(*a_defaultSectorY[iSector - 1]), ss_sectorSuffixed.str().c_str());
     }
     sectorNameTree->Branch(ss_sector.str().c_str(), &(*a_sectorName[iSector - 1]), 32000, 00);
   }
  
   // Loop over sectors for getting default APE
  
   for (auto& i_sector : m_tkSector_) {
     double defaultApeX(0.);
     double defaultApeY(0.);
     unsigned int nModules(0);
     for (auto const& i_rawId : i_sector.second.v_rawId) {
       std::vector<AlignTransformErrorExtended> alignErrors = alignmentErrors->m_alignError;
       for (auto const& i_alignError : alignErrors) {
         if (i_rawId == i_alignError.rawId()) {
           CLHEP::HepSymMatrix errMatrix = i_alignError.matrix();
           defaultApeX += errMatrix[0][0];
           defaultApeY += errMatrix[1][1];
           nModules++;
         }
       }
     }
     *a_defaultSectorX[i_sector.first - 1] = defaultApeX / nModules;
     *a_defaultSectorY[i_sector.first - 1] = defaultApeY / nModules;
   }
  
   sectorNameTree->Fill();
   sectorNameTree->Write("nameTree");
   defaultTreeX->Fill();
   defaultTreeX->Write("iterTreeX");
   defaultTreeY->Fill();
   defaultTreeY->Write("iterTreeY");
  
   defaultFile->Close();
   delete defaultFile;
   for (unsigned int i = 0; i < a_defaultSectorX.size(); i++) {
     delete a_defaultSectorX[i];
     delete a_defaultSectorY[i];
     delete a_sectorName[i];
   }
 }

References alignmentErrorToken_, edm::EventSetup::getData(), mps_fire::i, AlignmentErrorsExtended::m_alignError, m_tkSector_, resultFile_, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ beginJob()

void ApeTreeCreateDefault::beginJob ( )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 487 of file ApeTreeCreateDefault.cc.

487 { this->sectorBuilder(); }

References sectorBuilder().

◆ checkIntervalsForSectors()

bool ApeTreeCreateDefault::checkIntervalsForSectors	(	const unsigned int	sectorCounter,
		const std::vector< double > &	v_id
	)		const

private

Definition at line 324 of file ApeTreeCreateDefault.cc.

                                                                                          {
   if (v_id.empty())
     return true;
   if (v_id.size() % 2 == 1) {
     edm::LogError("SectorBuilder")
         << "Incorrect Sector Definition: Position Vectors need even number of arguments (Intervals)"
         << "\n... sector selection is not applied, sector " << sectorCounter << " is not built";
     return false;
   }
   int entry(0);
   double intervalBegin(999.);
   for (auto const& i_id : v_id) {
     ++entry;
     if (entry % 2 == 1)
       intervalBegin = i_id;
     if (entry % 2 == 0 && intervalBegin > i_id) {
       edm::LogError("SectorBuilder") << "Incorrect Sector Definition (Position Vector Intervals): \t" << intervalBegin
                                      << " is bigger than " << i_id << " but is expected to be smaller"
                                      << "\n... sector selection is not applied, sector " << sectorCounter
                                      << " is not built";
       return false;
     }
   }
   return true;
 }

References mps_splice::entry.

Referenced by sectorBuilder().

◆ checkModuleBools()

bool ApeTreeCreateDefault::checkModuleBools	(	const bool	id,
		const std::vector< unsigned int > &	v_id
	)		const

private

Definition at line 361 of file ApeTreeCreateDefault.cc.

                                                                                                     {
   if (v_id.empty())
     return true;
   for (auto const& i_id : v_id) {
     if (1 == i_id && id)
       return true;
     if (2 == i_id && !id)
       return true;
   }
   return false;
 }

Referenced by sectorBuilder().

◆ checkModuleDirections()

bool ApeTreeCreateDefault::checkModuleDirections	(	const int	id,
		const std::vector< int > &	v_id
	)		const

private

Definition at line 373 of file ApeTreeCreateDefault.cc.

                                                                                                {
   if (v_id.empty())
     return true;
   for (auto const& i_id : v_id) {
     if (id == i_id)
       return true;
   }
   return false;
 }

Referenced by sectorBuilder().

◆ checkModuleIds()

bool ApeTreeCreateDefault::checkModuleIds	(	const unsigned int	id,
		const std::vector< unsigned int > &	v_id
	)		const

private

Definition at line 351 of file ApeTreeCreateDefault.cc.

                                                                                                           {
   if (v_id.empty())
     return true;
   for (auto const& i_id : v_id) {
     if (id == i_id)
       return true;
   }
   return false;
 }

Referenced by sectorBuilder().

◆ checkModulePositions()

bool ApeTreeCreateDefault::checkModulePositions	(	const float	id,
		const std::vector< double > &	v_id
	)		const

private

Definition at line 383 of file ApeTreeCreateDefault.cc.

                                                                                                    {
   if (v_id.empty())
     return true;
   int entry(0);
   double intervalBegin(999.);
   for (auto const& i_id : v_id) {
     ++entry;
     if (entry % 2 == 1)
       intervalBegin = i_id;
     if (entry % 2 == 0 && id >= intervalBegin && id < i_id)
       return true;
   }
   return false;
 }

References mps_splice::entry.

Referenced by sectorBuilder().

◆ endJob()

void ApeTreeCreateDefault::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 490 of file ApeTreeCreateDefault.cc.

490 {}

Referenced by o2olib.O2ORunMgr::executeJob().

◆ fillDescriptions()

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

static

Definition at line 492 of file ApeTreeCreateDefault.cc.

                                                                                       {
   edm::ParameterSetDescription desc;
   edm::ParameterSetDescription sector;
  
   std::vector<unsigned> emptyUnsignedIntVector;
   std::vector<int> emptyIntVector;
   std::vector<double> emptyDoubleVector;
   sector.add<std::string>("name", "default");
   sector.add<std::vector<unsigned>>("rawId", emptyUnsignedIntVector);
   sector.add<std::vector<unsigned>>("subdetId", emptyUnsignedIntVector);
   sector.add<std::vector<unsigned>>("layer", emptyUnsignedIntVector);
   sector.add<std::vector<unsigned>>("side", emptyUnsignedIntVector);
   sector.add<std::vector<unsigned>>("half", emptyUnsignedIntVector);
   sector.add<std::vector<unsigned>>("rod", emptyUnsignedIntVector);
   sector.add<std::vector<unsigned>>("ring", emptyUnsignedIntVector);
   sector.add<std::vector<unsigned>>("petal", emptyUnsignedIntVector);
   sector.add<std::vector<unsigned>>("blade", emptyUnsignedIntVector);
   sector.add<std::vector<unsigned>>("panel", emptyUnsignedIntVector);
   sector.add<std::vector<unsigned>>("outerInner", emptyUnsignedIntVector);
   sector.add<std::vector<unsigned>>("module", emptyUnsignedIntVector);
   sector.add<std::vector<unsigned>>("nStrips", emptyUnsignedIntVector);
   sector.add<std::vector<unsigned>>("isDoubleSide", emptyUnsignedIntVector);
   sector.add<std::vector<unsigned>>("isRPhi", emptyUnsignedIntVector);
   sector.add<std::vector<unsigned>>("isStereo", emptyUnsignedIntVector);
   sector.add<std::vector<int>>("uDirection", emptyIntVector);
   sector.add<std::vector<int>>("vDirection", emptyIntVector);
   sector.add<std::vector<int>>("wDirection", emptyIntVector);
   sector.add<std::vector<double>>("posR", emptyDoubleVector);
   sector.add<std::vector<double>>("posPhi", emptyDoubleVector);
   sector.add<std::vector<double>>("posEta", emptyDoubleVector);
   sector.add<std::vector<double>>("posX", emptyDoubleVector);
   sector.add<std::vector<double>>("posY", emptyDoubleVector);
   sector.add<std::vector<double>>("posZ", emptyDoubleVector);
  
   desc.add<std::string>("resultFile", "defaultAPE.root");
   desc.add<std::string>("trackerTreeFile");
   desc.addVPSet("sectors", sector);
  
   descriptions.add("apeTreeCreateDefault", desc);
 }

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

◆ sectorBuilder()

void ApeTreeCreateDefault::sectorBuilder ( )

private

Definition at line 115 of file ApeTreeCreateDefault.cc.

                                          {
   // Same procedure as in ApeEstimator.cc
   TFile* tkTreeFile(TFile::Open(trackerTreeFile_.c_str()));
   if (tkTreeFile) {
     edm::LogInfo("SectorBuilder") << "TrackerTreeFile OK";
   } else {
     edm::LogError("SectorBuilder") << "TrackerTreeFile not found";
     return;
   }
   TTree* tkTree(nullptr);
   tkTreeFile->GetObject("TrackerTreeGenerator/TrackerTree/TrackerTree", tkTree);
   if (tkTree) {
     edm::LogInfo("SectorBuilder") << "TrackerTree OK";
   } else {
     edm::LogError("SectorBuilder") << "TrackerTree not found in file";
     return;
   }
  
   unsigned int rawId(999), subdetId(999), layer(999), side(999), half(999), rod(999), ring(999), petal(999), blade(999),
       panel(999), outerInner(999), module(999), nStrips(999);
   bool isDoubleSide(false), isRPhi(false), isStereo(false);
   int uDirection(999), vDirection(999), wDirection(999);
   float posR(999.F), posPhi(999.F), posEta(999.F), posX(999.F), posY(999.F), posZ(999.F);
  
   tkTree->SetBranchAddress("RawId", &rawId);
   tkTree->SetBranchAddress("SubdetId", &subdetId);
   tkTree->SetBranchAddress("Layer", &layer);
   tkTree->SetBranchAddress("Side", &side);
   tkTree->SetBranchAddress("Half", &half);
   tkTree->SetBranchAddress("Rod", &rod);
   tkTree->SetBranchAddress("Ring", &ring);
   tkTree->SetBranchAddress("Petal", &petal);
   tkTree->SetBranchAddress("Blade", &blade);
   tkTree->SetBranchAddress("Panel", &panel);
   tkTree->SetBranchAddress("OuterInner", &outerInner);
   tkTree->SetBranchAddress("Module", &module);
   tkTree->SetBranchAddress("NStrips", &nStrips);
   tkTree->SetBranchAddress("IsDoubleSide", &isDoubleSide);
   tkTree->SetBranchAddress("IsRPhi", &isRPhi);
   tkTree->SetBranchAddress("IsStereo", &isStereo);
   tkTree->SetBranchAddress("UDirection", &uDirection);
   tkTree->SetBranchAddress("VDirection", &vDirection);
   tkTree->SetBranchAddress("WDirection", &wDirection);
   tkTree->SetBranchAddress("PosR", &posR);
   tkTree->SetBranchAddress("PosPhi", &posPhi);
   tkTree->SetBranchAddress("PosEta", &posEta);
   tkTree->SetBranchAddress("PosX", &posX);
   tkTree->SetBranchAddress("PosY", &posY);
   tkTree->SetBranchAddress("PosZ", &posZ);
  
   int nModules(tkTree->GetEntries());
   TrackerSectorStruct allSectors;
  
   //Loop over all Sectors
   unsigned int sectorCounter(0);
   std::vector<edm::ParameterSet> v_sectorDef(sectors_);
   edm::LogInfo("SectorBuilder") << "There are " << v_sectorDef.size() << " Sectors defined";
  
   for (auto const& parSet : v_sectorDef) {
     ++sectorCounter;
     const std::string& sectorName(parSet.getParameter<std::string>("name"));
     std::vector<unsigned int> v_rawId(parSet.getParameter<std::vector<unsigned int>>("rawId")),
         v_subdetId(parSet.getParameter<std::vector<unsigned int>>("subdetId")),
         v_layer(parSet.getParameter<std::vector<unsigned int>>("layer")),
         v_side(parSet.getParameter<std::vector<unsigned int>>("side")),
         v_half(parSet.getParameter<std::vector<unsigned int>>("half")),
         v_rod(parSet.getParameter<std::vector<unsigned int>>("rod")),
         v_ring(parSet.getParameter<std::vector<unsigned int>>("ring")),
         v_petal(parSet.getParameter<std::vector<unsigned int>>("petal")),
         v_blade(parSet.getParameter<std::vector<unsigned int>>("blade")),
         v_panel(parSet.getParameter<std::vector<unsigned int>>("panel")),
         v_outerInner(parSet.getParameter<std::vector<unsigned int>>("outerInner")),
         v_module(parSet.getParameter<std::vector<unsigned int>>("module")),
         v_nStrips(parSet.getParameter<std::vector<unsigned int>>("nStrips")),
         v_isDoubleSide(parSet.getParameter<std::vector<unsigned int>>("isDoubleSide")),
         v_isRPhi(parSet.getParameter<std::vector<unsigned int>>("isRPhi")),
         v_isStereo(parSet.getParameter<std::vector<unsigned int>>("isStereo"));
     std::vector<int> v_uDirection(parSet.getParameter<std::vector<int>>("uDirection")),
         v_vDirection(parSet.getParameter<std::vector<int>>("vDirection")),
         v_wDirection(parSet.getParameter<std::vector<int>>("wDirection"));
     std::vector<double> v_posR(parSet.getParameter<std::vector<double>>("posR")),
         v_posPhi(parSet.getParameter<std::vector<double>>("posPhi")),
         v_posEta(parSet.getParameter<std::vector<double>>("posEta")),
         v_posX(parSet.getParameter<std::vector<double>>("posX")),
         v_posY(parSet.getParameter<std::vector<double>>("posY")),
         v_posZ(parSet.getParameter<std::vector<double>>("posZ"));
  
     if (!this->checkIntervalsForSectors(sectorCounter, v_posR) ||
         !this->checkIntervalsForSectors(sectorCounter, v_posPhi) ||
         !this->checkIntervalsForSectors(sectorCounter, v_posEta) ||
         !this->checkIntervalsForSectors(sectorCounter, v_posX) ||
         !this->checkIntervalsForSectors(sectorCounter, v_posY) ||
         !this->checkIntervalsForSectors(sectorCounter, v_posZ)) {
       continue;
     }
  
     TrackerSectorStruct tkSector;
     tkSector.name = sectorName;
  
     ReducedTrackerTreeVariables tkTreeVar;
  
     //Loop over all Modules
     for (int module = 0; module < nModules; ++module) {
       tkTree->GetEntry(module);
  
       if (sectorCounter == 1) {
         tkTreeVar.subdetId = subdetId;
         tkTreeVar.nStrips = nStrips;
         tkTreeVar.uDirection = uDirection;
         tkTreeVar.vDirection = vDirection;
         tkTreeVar.wDirection = wDirection;
         m_tkTreeVar_[rawId] = tkTreeVar;
       }
       //Check if modules from Sector builder equal those from TrackerTree
       if (!this->checkModuleIds(rawId, v_rawId))
         continue;
       if (!this->checkModuleIds(subdetId, v_subdetId))
         continue;
       if (!this->checkModuleIds(layer, v_layer))
         continue;
       if (!this->checkModuleIds(side, v_side))
         continue;
       if (!this->checkModuleIds(half, v_half))
         continue;
       if (!this->checkModuleIds(rod, v_rod))
         continue;
       if (!this->checkModuleIds(ring, v_ring))
         continue;
       if (!this->checkModuleIds(petal, v_petal))
         continue;
       if (!this->checkModuleIds(blade, v_blade))
         continue;
       if (!this->checkModuleIds(panel, v_panel))
         continue;
       if (!this->checkModuleIds(outerInner, v_outerInner))
         continue;
       if (!this->checkModuleIds(module, v_module))
         continue;
       if (!this->checkModuleIds(nStrips, v_nStrips))
         continue;
       if (!this->checkModuleBools(isDoubleSide, v_isDoubleSide))
         continue;
       if (!this->checkModuleBools(isRPhi, v_isRPhi))
         continue;
       if (!this->checkModuleBools(isStereo, v_isStereo))
         continue;
       if (!this->checkModuleDirections(uDirection, v_uDirection))
         continue;
       if (!this->checkModuleDirections(vDirection, v_vDirection))
         continue;
       if (!this->checkModuleDirections(wDirection, v_wDirection))
         continue;
       if (!this->checkModulePositions(posR, v_posR))
         continue;
       if (!this->checkModulePositions(posPhi, v_posPhi))
         continue;
       if (!this->checkModulePositions(posEta, v_posEta))
         continue;
       if (!this->checkModulePositions(posX, v_posX))
         continue;
       if (!this->checkModulePositions(posY, v_posY))
         continue;
       if (!this->checkModulePositions(posZ, v_posZ))
         continue;
  
       tkSector.v_rawId.push_back(rawId);
       bool moduleSelected(false);
       for (auto const& i_rawId : allSectors.v_rawId) {
         if (rawId == i_rawId)
           moduleSelected = true;
       }
       if (!moduleSelected)
         allSectors.v_rawId.push_back(rawId);
     }
  
     // Stops you from combining pixel and strip detector into one sector
     bool isPixel(false);
     bool isStrip(false);
     for (auto const& i_rawId : tkSector.v_rawId) {
       switch (m_tkTreeVar_[i_rawId].subdetId) {
         case PixelSubdetector::PixelBarrel:
         case PixelSubdetector::PixelEndcap:
           isPixel = true;
           break;
         case StripSubdetector::TIB:
         case StripSubdetector::TOB:
         case StripSubdetector::TID:
         case StripSubdetector::TEC:
           isStrip = true;
           break;
       }
     }
  
     if (isPixel && isStrip) {
       edm::LogError("SectorBuilder")
           << "Incorrect Sector Definition: there are pixel and strip modules within one sector"
           << "\n... sector selection is not applied, sector " << sectorCounter << " is not built";
       continue;
     }
     tkSector.isPixel = isPixel;
  
     m_tkSector_[sectorCounter] = tkSector;
     edm::LogInfo("SectorBuilder") << "There are " << tkSector.v_rawId.size() << " Modules in Sector " << sectorCounter;
   }
   noSectors = sectorCounter;
   return;
 }

References checkIntervalsForSectors(), checkModuleBools(), checkModuleDirections(), checkModuleIds(), checkModulePositions(), F(), fastTrackerRecHitType::isPixel(), TrackerSectorStruct::isPixel, phase1PixelTopology::layer, m_tkSector_, m_tkTreeVar_, callgraph::module, TrackerSectorStruct::name, noSectors, ReducedTrackerTreeVariables::nStrips, me0TriggerPseudoDigis_cff::nStrips, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, RecoTauValidation_cfi::posX, RecoTauValidation_cfi::posY, relativeConstraints::ring, sectors_, AlCaHLTBitMon_QueryRunRegistry::string, ReducedTrackerTreeVariables::subdetId, StripSubdetector::TEC, StripSubdetector::TIB, StripSubdetector::TID, StripSubdetector::TOB, trackerTreeFile_, ReducedTrackerTreeVariables::uDirection, TrackerSectorStruct::v_rawId, ReducedTrackerTreeVariables::vDirection, and ReducedTrackerTreeVariables::wDirection.

Referenced by beginJob().

Member Data Documentation

◆ alignmentErrorToken_

const edm::ESGetToken<AlignmentErrorsExtended, TrackerAlignmentErrorExtendedRcd> ApeTreeCreateDefault::alignmentErrorToken_

private

Definition at line 83 of file ApeTreeCreateDefault.cc.

Referenced by analyze().

◆ m_tkSector_

std::map<unsigned int, TrackerSectorStruct> ApeTreeCreateDefault::m_tkSector_

private

Definition at line 88 of file ApeTreeCreateDefault.cc.

Referenced by analyze(), and sectorBuilder().

◆ m_tkTreeVar_

std::map<unsigned int, ReducedTrackerTreeVariables> ApeTreeCreateDefault::m_tkTreeVar_

private

Definition at line 89 of file ApeTreeCreateDefault.cc.

Referenced by sectorBuilder().

◆ noSectors

unsigned int ApeTreeCreateDefault::noSectors

private

Definition at line 90 of file ApeTreeCreateDefault.cc.

Referenced by sectorBuilder().

◆ resultFile_

const std::string ApeTreeCreateDefault::resultFile_

private

Definition at line 84 of file ApeTreeCreateDefault.cc.

Referenced by analyze().

◆ sectors_

const std::vector<edm::ParameterSet> ApeTreeCreateDefault::sectors_

private

Definition at line 86 of file ApeTreeCreateDefault.cc.

Referenced by sectorBuilder().

◆ trackerTreeFile_

const std::string ApeTreeCreateDefault::trackerTreeFile_

private

Definition at line 85 of file ApeTreeCreateDefault.cc.

Referenced by sectorBuilder().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ApeTreeCreateDefault()

◆ ~ApeTreeCreateDefault()

Member Function Documentation

◆ analyze()

◆ beginJob()

◆ checkIntervalsForSectors()

◆ checkModuleBools()

◆ checkModuleDirections()

◆ checkModuleIds()

◆ checkModulePositions()

◆ endJob()

◆ fillDescriptions()

◆ sectorBuilder()

Member Data Documentation

◆ alignmentErrorToken_

◆ m_tkSector_

◆ m_tkTreeVar_

◆ noSectors

◆ resultFile_

◆ sectors_

◆ trackerTreeFile_