#include <TkModuleGroupSelector.h>

Public Member Functions
edm::RunNumber_t	firstRunOfIOV (unsigned int iovNum) const
	First run of iov (0 if iovNum not treated). More...

unsigned int	getNumberOfParameters () const

int	getParameterIndexFromDetId (unsigned int detId, edm::RunNumber_t run) const

unsigned int	numIovs () const
	Total number of IOVs. More...

	TkModuleGroupSelector (AlignableTracker *aliTracker, const edm::ParameterSet &cfg, const std::vector< int > &sdets)
	Constructor. More...

virtual	~TkModuleGroupSelector ()
	Destructor. More...

Private Member Functions
bool	createGroup (unsigned int &Id, const std::vector< edm::RunNumber_t > &range, const std::list< Alignable * > &selected_alis, const edm::RunNumber_t refrun)

void	createModuleGroups (AlignableTracker *aliTracker, const edm::VParameterSet &granularityConfig, const std::vector< edm::RunNumber_t > &defaultRunRange, edm::RunNumber_t defaultReferenceRun)

void	fillDetIdMap (const unsigned int detid, const unsigned int groupid)

const bool	testSplitOption (const edm::ParameterSet &pset) const

void	verifyParameterNames (const edm::ParameterSet &pset, unsigned int psetnr) const

Private Attributes
std::vector< unsigned int >	firstId_

std::vector< edm::RunNumber_t >	globalRunRange_

std::map< unsigned int, unsigned int >	mapDetIdGroupId_

unsigned int	nparameters_

std::vector< edm::RunNumber_t >	referenceRun_

std::vector< std::vector< edm::RunNumber_t > >	runRange_

std::vector< int >	subdetids_

Detailed Description

Definition at line 35 of file TkModuleGroupSelector.h.

Constructor & Destructor Documentation

◆ TkModuleGroupSelector()

TkModuleGroupSelector::TkModuleGroupSelector	(	AlignableTracker *	aliTracker,
		const edm::ParameterSet &	cfg,
		const std::vector< int > &	sdets
	)

explicit

Constructor.

Definition at line 22 of file TkModuleGroupSelector.cc.

     : nparameters_(0), subdetids_(sdets) {
   //verify that all provided options are known
   std::vector<std::string> parameterNames = cfg.getParameterNames();
   for (std::vector<std::string>::const_iterator iParam = parameterNames.begin(); iParam != parameterNames.end();
        ++iParam) {
     const std::string name = (*iParam);
     if (name != "RunRange" && name != "ReferenceRun" && name != "Granularity") {
       throw cms::Exception("BadConfig") << "@SUB=TkModuleGroupSelector::TkModuleGroupSelector:"
                                         << " Unknown parameter name '" << name << "' in PSet. Maybe a typo?";
     }
   }
  
   //extract the reference run range if defined
   const edm::RunNumber_t defaultReferenceRun =
       (cfg.exists("ReferenceRun") ? cfg.getParameter<edm::RunNumber_t>("ReferenceRun") : 0);
  
   //extract run range to be used for all module groups (if not locally overwritten)
   const std::vector<edm::RunNumber_t> defaultRunRange =
       (cfg.exists("RunRange") ? cfg.getParameter<std::vector<edm::RunNumber_t> >("RunRange")
                               : std::vector<edm::RunNumber_t>());
  
   // finally create everything from configuration
   this->createModuleGroups(
       aliTracker, cfg.getParameter<edm::VParameterSet>("Granularity"), defaultRunRange, defaultReferenceRun);
 }

References looper::cfg, createModuleGroups(), Exception, Skims_PA_cff::name, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ ~TkModuleGroupSelector()

virtual TkModuleGroupSelector::~TkModuleGroupSelector ( )

inlinevirtual

Destructor.

Definition at line 43 of file TkModuleGroupSelector.h.

43 {};

Member Function Documentation

◆ createGroup()

bool TkModuleGroupSelector::createGroup	(	unsigned int &	Id,
		const std::vector< edm::RunNumber_t > &	range,
		const std::list< Alignable * > &	selected_alis,
		const edm::RunNumber_t	refrun
	)

private

Definition at line 74 of file TkModuleGroupSelector.cc.

                                                                      {
   bool modules_selected = false;
  
   referenceRun_.push_back(refrun);
   firstId_.push_back(Id);
   runRange_.push_back(range);
   for (std::list<Alignable *>::const_iterator it = selected_alis.begin(); it != selected_alis.end(); ++it) {
     this->fillDetIdMap((*it)->id(), firstId_.size() - 1);
     modules_selected = true;
   }
   if (refrun > 0 && !range.empty()) {  //FIXME: last condition not really needed?
     Id += range.size() - 1;
     nparameters_ += range.size() - 1;
   } else {
     Id += range.size();
     nparameters_ += range.size();
   }
  
   if (refrun > 0 && range.front() > refrun) {  //range.size() > 0 checked before
     throw cms::Exception("BadConfig") << "@SUB=TkModuleGroupSelector::createGroup:\n"
                                       << "Invalid combination of reference run number and specified run dependence"
                                       << "\n in module group " << firstId_.size() << "."
                                       << "\n Reference run number (" << refrun << ") is smaller than starting run "
                                       << "\n number (" << range.front() << ") of first IOV.";
   }
   return modules_selected;
 }

References Exception, fillDetIdMap(), firstId_, nparameters_, FastTimerService_cff::range, referenceRun_, and runRange_.

Referenced by createModuleGroups().

◆ createModuleGroups()

void TkModuleGroupSelector::createModuleGroups	(	AlignableTracker *	aliTracker,
		const edm::VParameterSet &	granularityConfig,
		const std::vector< edm::RunNumber_t > &	defaultRunRange,
		edm::RunNumber_t	defaultReferenceRun
	)

private

Definition at line 120 of file TkModuleGroupSelector.cc.

                                                                                    {
   std::set<edm::RunNumber_t> localRunRange;
   nparameters_ = 0;
   unsigned int Id = 0;
   unsigned int psetnr = 0;
   //loop over all LA groups
   for (edm::VParameterSet::const_iterator pset = granularityConfig.begin(); pset != granularityConfig.end(); ++pset) {
     //test for unknown parameters
     this->verifyParameterNames((*pset), psetnr);
     psetnr++;
  
     bool modules_selected = false;  //track whether at all a module has been selected in this group
     const std::vector<edm::RunNumber_t> range =
         ((*pset).exists("RunRange") ? pset->getParameter<std::vector<edm::RunNumber_t> >("RunRange") : defaultRunRange);
     if (range.empty()) {
       throw cms::Exception("BadConfig") << "@SUB=TkModuleGroupSelector::createModuleGroups:\n"
                                         << "Run range array empty!";
     }
     const bool split = this->testSplitOption((*pset));
  
     edm::RunNumber_t refrun = 0;
     if ((*pset).exists("ReferenceRun")) {
       refrun = (*pset).getParameter<edm::RunNumber_t>("ReferenceRun");
     } else {
       refrun = defaultReferenceRun;
     }
  
     AlignmentParameterSelector selector(aliTracker);
     selector.clear();
     selector.addSelections((*pset).getParameter<edm::ParameterSet>("levels"));
  
     const auto &alis = selector.selectedAlignables();
     std::list<Alignable *> selected_alis;
     for (const auto &it : alis) {
       const auto &aliDaughts = it->deepComponents();
       for (const auto &iD : aliDaughts) {
         if (iD->alignableObjectId() == align::AlignableDetUnit || iD->alignableObjectId() == align::AlignableDet) {
           if (split) {
             modules_selected = this->createGroup(Id, range, std::list<Alignable *>(1, iD), refrun);
           } else {
             selected_alis.push_back(iD);
           }
         }
       }
     }
  
     if (!split) {
       modules_selected = this->createGroup(Id, range, selected_alis, refrun);
     }
  
     edm::RunNumber_t firstRun = 0;
     for (std::vector<edm::RunNumber_t>::const_iterator iRun = range.begin(); iRun != range.end(); ++iRun) {
       localRunRange.insert((*iRun));
       if ((*iRun) > firstRun) {
         firstRun = (*iRun);
       } else {
         throw cms::Exception("BadConfig") << "@SUB=TkModuleGroupSelector::createModuleGroups:"
                                           << " Run range not sorted.";
       }
     }
  
     if (!modules_selected) {
       throw cms::Exception("BadConfig") << "@SUB=TkModuleGroupSelector:createModuleGroups:"
                                         << " No module was selected in the module group selector in group "
                                         << (firstId_.size() - 1) << ".";
     }
   }
  
   //copy local set into the global vector of run boundaries
   for (std::set<edm::RunNumber_t>::const_iterator itRun = localRunRange.begin(); itRun != localRunRange.end();
        ++itRun) {
     globalRunRange_.push_back((*itRun));
   }
 }

References AlignmentParameterSelector::addSelections(), align::AlignableDet, align::AlignableDetUnit, AlignmentParameterSelector::clear(), createGroup(), Exception, firstId_, dataset::firstRun, globalRunRange_, nparameters_, muonDTDigis_cfi::pset, FastTimerService_cff::range, AlignmentParameterSelector::selectedAlignables(), submitPVValidationJobs::split(), testSplitOption(), and verifyParameterNames().

Referenced by TkModuleGroupSelector().

◆ fillDetIdMap()

void TkModuleGroupSelector::fillDetIdMap	(	const unsigned int	detid,
		const unsigned int	groupid
	)

private

Definition at line 52 of file TkModuleGroupSelector.cc.

                                                                                              {
   //only add new entries
   if (mapDetIdGroupId_.find(detid) == mapDetIdGroupId_.end()) {
     mapDetIdGroupId_.insert(std::pair<unsigned int, unsigned int>(detid, groupid));
   } else {
     throw cms::Exception("BadConfig") << "@SUB=TkModuleGroupSelector:fillDetIdMap:"
                                       << " Module with det ID " << detid << " configured in group " << groupid
                                       << " but it was already selected"
                                       << " in group " << mapDetIdGroupId_[detid] << ".";
   }
 }

References Exception, and mapDetIdGroupId_.

Referenced by createGroup().

◆ firstRunOfIOV()

edm::RunNumber_t TkModuleGroupSelector::firstRunOfIOV ( unsigned int iovNum ) const

First run of iov (0 if iovNum not treated).

Definition at line 205 of file TkModuleGroupSelector.cc.

                                                                              {
   return iovNum < this->numIovs() ? globalRunRange_.at(iovNum) : 0;
 }

References globalRunRange_, and numIovs().

Referenced by SiStripBackplaneCalibration::endOfJob(), and SiStripBackplaneCalibration::writeTree().

◆ getNumberOfParameters()

unsigned int TkModuleGroupSelector::getNumberOfParameters ( ) const

Definition at line 199 of file TkModuleGroupSelector.cc.

199 { return nparameters_; }

References nparameters_.

Referenced by SiStripBackplaneCalibration::beginOfJob().

◆ getParameterIndexFromDetId()

int TkModuleGroupSelector::getParameterIndexFromDetId	(	unsigned int	detId,
		edm::RunNumber_t	run
	)		const

Index of parameter for given detId (detId not treated => < 0) and the given run.

Definition at line 210 of file TkModuleGroupSelector.cc.

                                                                                                   {
   // Return the index of the parameter that is used for this DetId.
   // If this DetId is not treated, return values < 0.
  
   const DetId temp_id(detId);
  
   int index = -1;
  
   bool sel = false;
   for (std::vector<int>::const_iterator itSubDets = subdetids_.begin(); itSubDets != subdetids_.end(); ++itSubDets) {
     if (temp_id.det() == DetId::Tracker && temp_id.subdetId() == (*itSubDets)) {
       sel = true;
       break;
     }
   }
  
   if (temp_id.det() != DetId::Tracker || !sel)
     return -1;
  
   std::map<unsigned int, unsigned int>::const_iterator it = mapDetIdGroupId_.find(detId);
   if (it != mapDetIdGroupId_.end()) {
     const unsigned int iAlignableGroup = (*it).second;
     const std::vector<edm::RunNumber_t> &runs = runRange_.at(iAlignableGroup);
     const unsigned int id0 = firstId_.at(iAlignableGroup);
     const edm::RunNumber_t refrun = referenceRun_.at(iAlignableGroup);
  
     unsigned int iovNum = 0;
     for (; iovNum < runs.size(); ++iovNum) {
       if (runs[iovNum] > run)
         break;
     }
     if (iovNum == 0) {
       throw cms::Exception("BadConfig") << "@SUB=TkModuleGroupSelector::getParameterIndexFromDetId:\n"
                                         << "Run " << run << " not foreseen for detid '" << detId << "'"
                                         << " in module group " << iAlignableGroup << ".";
     } else {
       --iovNum;
     }
  
     //test whether the iov contains the reference run
     if (refrun > 0) {  //if > 0 a reference run number has been provided
       if (iovNum + 1 == runs.size()) {
         if (refrun >= runs[iovNum])
           return -1;
       } else if ((iovNum + 1) < runs.size()) {
         if (refrun >= runs[iovNum] && refrun < runs[iovNum + 1]) {
           return -1;
         }
       }
       if (run > refrun) {
         //iovNum > 0 due to checks in createGroup(...) and createModuleGroups(...)
         //remove IOV in which the reference run can be found
         iovNum -= 1;
       }
     }
  
     index = id0 + iovNum;
   }
   return index;
 }

References DetId::det(), Exception, firstId_, mapDetIdGroupId_, referenceRun_, writedatasetfile::run, runRange_, writedatasetfile::runs, EgammaValidation_Wenu_cff::sel, DetId::subdetId(), subdetids_, and DetId::Tracker.

Referenced by SiStripBackplaneCalibration::derivatives(), SiStripBackplaneCalibration::endOfJob(), SiStripBackplaneCalibration::getParameterForDetId(), and SiStripBackplaneCalibration::writeTree().

◆ numIovs()

unsigned int TkModuleGroupSelector::numIovs ( ) const

Total number of IOVs.

Definition at line 202 of file TkModuleGroupSelector.cc.

202 { return globalRunRange_.size(); }

References globalRunRange_.

Referenced by SiStripBackplaneCalibration::beginOfJob(), SiStripBackplaneCalibration::endOfJob(), and firstRunOfIOV().

◆ testSplitOption()

const bool TkModuleGroupSelector::testSplitOption ( const edm::ParameterSet & pset ) const

private

Definition at line 65 of file TkModuleGroupSelector.cc.

                                                                                    {
   bool split = false;
   if (pset.exists("split")) {
     split = pset.getParameter<bool>("split");
   }
   return split;
 }

References muonDTDigis_cfi::pset, and submitPVValidationJobs::split().

Referenced by createModuleGroups().

◆ verifyParameterNames()

void TkModuleGroupSelector::verifyParameterNames	(	const edm::ParameterSet &	pset,
		unsigned int	psetnr
	)		const

private

Definition at line 106 of file TkModuleGroupSelector.cc.

                                                                                                        {
   std::vector<std::string> parameterNames = pset.getParameterNames();
   for (std::vector<std::string>::const_iterator iParam = parameterNames.begin(); iParam != parameterNames.end();
        ++iParam) {
     const std::string name = (*iParam);
     if (name != "levels" && name != "RunRange" && name != "split" && name != "ReferenceRun") {
       throw cms::Exception("BadConfig") << "@SUB=TkModuleGroupSelector::verifyParameterNames:"
                                         << " Unknown parameter name '" << name << "' in PSet number " << psetnr
                                         << ". Maybe a typo?";
     }
   }
 }