CommonAlignmentAlgorithm/src/TkModuleGroupSelector.cc

/**
 * \file TkModuleGroupSelector.cc
 *
 *  \author Joerg Behr
 *  \date May 2013
 *  $Revision: 1.4 $
 *  $Date: 2013/05/31 14:50:52 $
 *  (last update by $Author: jbehr $)
 */

#include "Alignment/CommonAlignmentAlgorithm/interface/TkModuleGroupSelector.h"
#include "Alignment/CommonAlignmentAlgorithm/interface/AlignmentParameterSelector.h"
#include "Alignment/CommonAlignment/interface/Alignable.h"
#include "DataFormats/DetId/interface/DetId.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

#include <vector>
#include <map>
#include <set>

//============================================================================
TkModuleGroupSelector::TkModuleGroupSelector(AlignableTracker *aliTracker,
                                             const edm::ParameterSet &cfg,
                                             const std::vector<int> &sdets
                                             ) : 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);
}

//============================================================================
void TkModuleGroupSelector::fillDetIdMap(const unsigned int detid, const unsigned int groupid)
{
  //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] << ".";
  }
}

//============================================================================
const bool TkModuleGroupSelector::testSplitOption(const edm::ParameterSet &pset) const
{
  bool split = false;
  if(pset.exists("split")) {
    split = pset.getParameter<bool>("split");
  }
  return split;
}

//============================================================================
bool TkModuleGroupSelector::createGroup(
                                        unsigned int &Id, 
                                        const std::vector<edm::RunNumber_t> &range, 
                                        const std::list<Alignable*> &selected_alis,
                                        const edm::RunNumber_t refrun
                                        )
{
  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.size() > 0) { //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;
}

//============================================================================
void TkModuleGroupSelector::verifyParameterNames(const edm::ParameterSet &pset, unsigned int psetnr) const
{
  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?";
    }
  }
}


//============================================================================
void TkModuleGroupSelector::createModuleGroups(AlignableTracker *aliTracker,
                                               const edm::VParameterSet &granularityConfig,
                                               const std::vector<edm::RunNumber_t> &defaultRunRange,
                                               edm::RunNumber_t defaultReferenceRun)
{
  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 std::vector<Alignable*> &alis = selector.selectedAlignables();
    std::list<Alignable*> selected_alis;
    for(std::vector<Alignable*>::const_iterator it = alis.begin(); it != alis.end(); ++it) {
      const std::vector<Alignable*> &aliDaughts = (*it)->deepComponents();
      for (std::vector<Alignable*>::const_iterator iD = aliDaughts.begin();
           iD != aliDaughts.end(); ++iD) {
        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));
  }
}

//============================================================================
unsigned int TkModuleGroupSelector::getNumberOfParameters() const
{
  return nparameters_;
}

//============================================================================
unsigned int TkModuleGroupSelector::numIovs() const
{
  return globalRunRange_.size();
}

//============================================================================
edm::RunNumber_t TkModuleGroupSelector::firstRunOfIOV(unsigned int iovNum) const
{
  return iovNum < this->numIovs() ? globalRunRange_.at(iovNum) : 0;
}

//======================================================================
int TkModuleGroupSelector::getParameterIndexFromDetId(unsigned int detId,
                                                      edm::RunNumber_t run) const
{
  // 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);
    // assuming runs is never empty (checked in createModuleGroups(..))
    if (runs[0] > run) {
      throw cms::Exception("BadConfig")
        << "@SUB=TkModuleGroupSelector::getParameterIndexFromDetId:\n"
        << "Run " << run << " not foreseen for detid ('"<< detId <<"')"
        << " in module group " << iAlignableGroup << ".";
    }
    unsigned int iovNum = 0;
    for ( ; iovNum < runs.size(); ++iovNum) {
      if (run >= runs[iovNum]) break;
    }
    //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;
}
Revision:	1.5
Committed:	Wed Jun 19 08:33:03 2013 UTC (11 years, 10 months ago) by jbehr
Content type:	text/plain
Branch:	MAIN
CVS Tags:	CMSSW_6_2_0, V04-00-14, HEAD
Changes since 1.4:	+5 -5 lines
Log Message:	bug fix: consistency of reference run and specified run dependence was verified also when no reference run was provided.
#	User	Rev	Content
1	flucke	1.2	/**
2			* \file TkModuleGroupSelector.cc
3			*
4			* \author Joerg Behr
5			* \date May 2013
6	jbehr	1.5	* $Revision: 1.4 $
7			* $Date: 2013/05/31 14:50:52 $
8	jbehr	1.4	* (last update by $Author: jbehr $)
9	flucke	1.2	*/
10
11			#include "Alignment/CommonAlignmentAlgorithm/interface/TkModuleGroupSelector.h"
12			#include "Alignment/CommonAlignmentAlgorithm/interface/AlignmentParameterSelector.h"
13			#include "Alignment/CommonAlignment/interface/Alignable.h"
14			#include "DataFormats/DetId/interface/DetId.h"
15			#include "FWCore/MessageLogger/interface/MessageLogger.h"
16
17			#include <vector>
18			#include <map>
19			#include <set>
20
21			//============================================================================
22			TkModuleGroupSelector::TkModuleGroupSelector(AlignableTracker *aliTracker,
23			const edm::ParameterSet &cfg,
24			const std::vector<int> &sdets
25			) : nparameters_(0),
26			subdetids_(sdets)
27			{
28			//verify that all provided options are known
29			std::vector<std::string> parameterNames = cfg.getParameterNames();
30			for ( std::vector<std::string>::const_iterator iParam = parameterNames.begin();
31			iParam != parameterNames.end(); ++iParam) {
32			const std::string name = (*iParam);
33			if(
34			name != "RunRange" && name != "ReferenceRun" && name != "Granularity"
35			) {
36			throw cms::Exception("BadConfig")
37			<< "@SUB=TkModuleGroupSelector::TkModuleGroupSelector:"
38			<< " Unknown parameter name '" << name << "' in PSet. Maybe a typo?";
39			}
40			}
41
42
43			//extract the reference run range if defined
44			const edm::RunNumber_t defaultReferenceRun
45			= (cfg.exists("ReferenceRun") ? cfg.getParameter<edm::RunNumber_t>("ReferenceRun") : 0);
46
47			//extract run range to be used for all module groups (if not locally overwritten)
48			const std::vector<edm::RunNumber_t> defaultRunRange
49			= (cfg.exists("RunRange") ? cfg.getParameter<std::vector<edm::RunNumber_t> >("RunRange")
50			: std::vector<edm::RunNumber_t>());
51
52			// finally create everything from configuration
53			this->createModuleGroups(aliTracker, cfg.getParameter<edm::VParameterSet>("Granularity"),
54			defaultRunRange, defaultReferenceRun);
55			}
56
57			//============================================================================
58			void TkModuleGroupSelector::fillDetIdMap(const unsigned int detid, const unsigned int groupid)
59			{
60			//only add new entries
61			if(mapDetIdGroupId_.find(detid) == mapDetIdGroupId_.end()) {
62			mapDetIdGroupId_.insert(std::pair<unsigned int, unsigned int>(detid, groupid));
63			} else {
64			throw cms::Exception("BadConfig")
65			<< "@SUB=TkModuleGroupSelector:fillDetIdMap:"
66			<< " Module with det ID " << detid << " configured in group " << groupid
67			<< " but it was already selected"
68			<< " in group " << mapDetIdGroupId_[detid] << ".";
69			}
70			}
71
72			//============================================================================
73			const bool TkModuleGroupSelector::testSplitOption(const edm::ParameterSet &pset) const
74			{
75			bool split = false;
76			if(pset.exists("split")) {
77			split = pset.getParameter<bool>("split");
78			}
79			return split;
80			}
81
82			//============================================================================
83			bool TkModuleGroupSelector::createGroup(
84			unsigned int &Id,
85			const std::vector<edm::RunNumber_t> &range,
86			const std::list<Alignable*> &selected_alis,
87			const edm::RunNumber_t refrun
88			)
89			{
90			bool modules_selected = false;
91
92			referenceRun_.push_back(refrun);
93			firstId_.push_back(Id);
94			runRange_.push_back(range);
95			for(std::list<Alignable*>::const_iterator it = selected_alis.begin();
96			it != selected_alis.end(); it++) {
97			this->fillDetIdMap((*it)->id(), firstId_.size()-1);
98			modules_selected = true;
99			}
100			if(refrun > 0 && range.size() > 0) { //FIXME: last condition not really needed?
101			Id += range.size() - 1;
102			nparameters_ += range.size() - 1;
103			} else {
104			Id += range.size();
105			nparameters_ += range.size();
106			}
107	jbehr	1.4
108	jbehr	1.5	if(refrun > 0 && range.front() > refrun) { //range.size() > 0 checked before
109	jbehr	1.4	throw cms::Exception("BadConfig")
110			<< "@SUB=TkModuleGroupSelector::createGroup:\n"
111			<< "Invalid combination of reference run number and specified run dependence"
112			<< "\n in module group " << firstId_.size() << "."
113	jbehr	1.5	<< "\n Reference run number (" << refrun << ") is smaller than starting run "
114			<< "\n number (" << range.front() << ") of first IOV.";
115	jbehr	1.4	}
116	flucke	1.2	return modules_selected;
117			}
118
119			//============================================================================
120			void TkModuleGroupSelector::verifyParameterNames(const edm::ParameterSet &pset, unsigned int psetnr) const
121			{
122			std::vector<std::string> parameterNames = pset.getParameterNames();
123			for ( std::vector<std::string>::const_iterator iParam = parameterNames.begin();
124			iParam != parameterNames.end(); ++iParam) {
125			const std::string name = (*iParam);
126			if(
127			name != "levels" && name != "RunRange"
128			&& name != "split" && name != "ReferenceRun"
129			) {
130			throw cms::Exception("BadConfig")
131			<< "@SUB=TkModuleGroupSelector::verifyParameterNames:"
132			<< " Unknown parameter name '" << name << "' in PSet number " << psetnr << ". Maybe a typo?";
133			}
134			}
135			}
136
137
138			//============================================================================
139			void TkModuleGroupSelector::createModuleGroups(AlignableTracker *aliTracker,
140			const edm::VParameterSet &granularityConfig,
141			const std::vector<edm::RunNumber_t> &defaultRunRange,
142			edm::RunNumber_t defaultReferenceRun)
143			{
144			std::set<edm::RunNumber_t> localRunRange;
145			nparameters_ = 0;
146			unsigned int Id = 0;
147			unsigned int psetnr = 0;
148			//loop over all LA groups
149			for(edm::VParameterSet::const_iterator pset = granularityConfig.begin();
150			pset != granularityConfig.end();
151			++pset) {
152
153			//test for unknown parameters
154			this->verifyParameterNames((*pset),psetnr);
155			psetnr++;
156
157			bool modules_selected = false; //track whether at all a module has been selected in this group
158			const std::vector<edm::RunNumber_t> range =
159			((*pset).exists("RunRange") ? pset->getParameter<std::vector<edm::RunNumber_t> >("RunRange")
160			: defaultRunRange);
161			if(range.empty()) {
162			throw cms::Exception("BadConfig")
163			<< "@SUB=TkModuleGroupSelector::createModuleGroups:\n"
164			<< "Run range array empty!";
165			}
166			const bool split = this->testSplitOption((*pset));
167
168			edm::RunNumber_t refrun = 0;
169			if((*pset).exists("ReferenceRun")) {
170			refrun = (*pset).getParameter<edm::RunNumber_t>("ReferenceRun");
171			} else {
172			refrun = defaultReferenceRun;
173			}
174
175			AlignmentParameterSelector selector(aliTracker);
176			selector.clear();
177			selector.addSelections((*pset).getParameter<edm::ParameterSet> ("levels"));
178
179			const std::vector<Alignable*> &alis = selector.selectedAlignables();
180			std::list<Alignable*> selected_alis;
181			for(std::vector<Alignable*>::const_iterator it = alis.begin(); it != alis.end(); ++it) {
182			const std::vector<Alignable> &aliDaughts = (it)->deepComponents();
183			for (std::vector<Alignable*>::const_iterator iD = aliDaughts.begin();
184			iD != aliDaughts.end(); ++iD) {
185			if((iD)->alignableObjectId() == align::AlignableDetUnit \|\| (iD)->alignableObjectId() == align::AlignableDet) {
186			if(split) {
187			modules_selected = this->createGroup(Id, range, std::list<Alignable>(1,(iD)), refrun);
188			} else {
189			selected_alis.push_back((*iD));
190			}
191			}
192			}
193			}
194
195			if(!split) {
196			modules_selected = this->createGroup(Id, range, selected_alis, refrun);
197			}
198
199			edm::RunNumber_t firstRun = 0;
200			for(std::vector<edm::RunNumber_t>::const_iterator iRun = range.begin();
201			iRun != range.end(); ++iRun) {
202			localRunRange.insert((*iRun));
203			if((*iRun) > firstRun) {
204			firstRun = (*iRun);
205			} else {
206			throw cms::Exception("BadConfig")
207			<< "@SUB=TkModuleGroupSelector::createModuleGroups:"
208			<< " Run range not sorted.";
209			}
210			}
211
212			if(!modules_selected) {
213			throw cms::Exception("BadConfig")
214			<< "@SUB=TkModuleGroupSelector:createModuleGroups:"
215			<< " No module was selected in the module group selector in group " << (firstId_.size()-1)<< ".";
216			}
217			}
218
219			//copy local set into the global vector of run boundaries
220			for(std::set<edm::RunNumber_t>::const_iterator itRun = localRunRange.begin();
221			itRun != localRunRange.end(); itRun++) {
222			globalRunRange_.push_back((*itRun));
223			}
224			}
225
226			//============================================================================
227			unsigned int TkModuleGroupSelector::getNumberOfParameters() const
228			{
229			return nparameters_;
230			}
231
232			//============================================================================
233			unsigned int TkModuleGroupSelector::numIovs() const
234			{
235			return globalRunRange_.size();
236			}
237
238			//============================================================================
239			edm::RunNumber_t TkModuleGroupSelector::firstRunOfIOV(unsigned int iovNum) const
240			{
241			return iovNum < this->numIovs() ? globalRunRange_.at(iovNum) : 0;
242			}
243
244			//======================================================================
245			int TkModuleGroupSelector::getParameterIndexFromDetId(unsigned int detId,
246			edm::RunNumber_t run) const
247			{
248			// Return the index of the parameter that is used for this DetId.
249			// If this DetId is not treated, return values < 0.
250
251			const DetId temp_id(detId);
252
253			int index = -1;
254
255			bool sel = false;
256			for(std::vector<int>::const_iterator itSubDets = subdetids_.begin();
257			itSubDets != subdetids_.end();
258			itSubDets++) {
259			if (temp_id.det() == DetId::Tracker && temp_id.subdetId() == (*itSubDets)) {
260			sel = true;
261			break;
262			}
263			}
264
265			if (temp_id.det() != DetId::Tracker \|\| !sel) return -1;
266
267			std::map<unsigned int, unsigned int>::const_iterator it = mapDetIdGroupId_.find(detId);
268			if(it != mapDetIdGroupId_.end()) {
269			const unsigned int iAlignableGroup = (*it).second;
270			const std::vector<edm::RunNumber_t> &runs = runRange_.at(iAlignableGroup);
271			const unsigned int id0 = firstId_.at(iAlignableGroup);
272			const edm::RunNumber_t refrun = referenceRun_.at(iAlignableGroup);
273			// assuming runs is never empty (checked in createModuleGroups(..))
274			if (runs[0] > run) {
275			throw cms::Exception("BadConfig")
276			<< "@SUB=TkModuleGroupSelector::getParameterIndexFromDetId:\n"
277	jbehr	1.4	<< "Run " << run << " not foreseen for detid ('"<< detId <<"')"
278			<< " in module group " << iAlignableGroup << ".";
279	flucke	1.2	}
280			unsigned int iovNum = 0;
281			for ( ; iovNum < runs.size(); ++iovNum) {
282			if (run >= runs[iovNum]) break;
283			}
284			//test whether the iov contains the reference run
285			if(refrun > 0) { //if > 0 a reference run number has been provided
286			if(iovNum+1 == runs.size()) {
287			if(refrun >= runs[iovNum])
288			return -1;
289			} else if( (iovNum+1) < runs.size()) {
290			if(refrun >= runs[iovNum] && refrun < runs[iovNum+1]) {
291			return -1;
292			}
293	jbehr	1.4	}
294			if(run > refrun) {
295			//iovNum > 0 due to checks in createGroup(...) and createModuleGroups(...)
296			//remove IOV in which the reference run can be found
297			iovNum -= 1;
298	flucke	1.2	}
299			}
300
301			index = id0 + iovNum;
302			}
303			return index;
304			}