CommonAlignmentAlgorithm/src/AlignmentParameterBuilder.cc

/** \file AlignableParameterBuilder.cc
 *
 *  $Date: 2006/11/08 16:36:22 $
 *  $Revision: 1.11 $
 */

#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"

#include "Geometry/CommonDetAlgo/interface/AlgebraicObjects.h"
#include "Alignment/CommonAlignment/interface/Alignable.h"
#include "Alignment/CommonAlignment/interface/AlignableDet.h"

#include "Alignment/CommonAlignmentParametrization/interface/RigidBodyAlignmentParameters.h"
#include "Alignment/CommonAlignmentParametrization/interface/CompositeRigidBodyAlignmentParameters.h"

//#include "Alignment/TrackerAlignment/interface/AlignableTracker.h" not needed since only forwarded

#include "Alignment/CommonAlignmentAlgorithm/interface/AlignmentParameterSelector.h"
#include "Alignment/CommonAlignmentAlgorithm/interface/SelectionUserVariables.h"

// This class's header

#include "Alignment/CommonAlignmentAlgorithm/interface/AlignmentParameterBuilder.h"


//__________________________________________________________________________________________________
AlignmentParameterBuilder::AlignmentParameterBuilder(AlignableTracker* alignableTracker) :
  theAlignables(), theAlignableTracker(alignableTracker)
{
}

//__________________________________________________________________________________________________
AlignmentParameterBuilder::AlignmentParameterBuilder(AlignableTracker* alignableTracker,
                                                     const edm::ParameterSet &pSet) :
  theAlignables(), theAlignableTracker(alignableTracker)
{
  this->addSelections(pSet.getParameter<edm::ParameterSet>("Selector"));
}

//__________________________________________________________________________________________________
unsigned int AlignmentParameterBuilder::addSelections(const edm::ParameterSet &pSet)
{

   AlignmentParameterSelector selector(theAlignableTracker);
   const unsigned int addedSets = selector.addSelections(pSet);

   const std::vector<Alignable*> &alignables = selector.selectedAlignables();
   const std::vector<std::vector<char> > &paramSels = selector.selectedParameters();

   std::vector<Alignable*>::const_iterator iAli = alignables.begin();
   std::vector<std::vector<char> >::const_iterator iParamSel = paramSels.begin();
   unsigned int nHigherLevel = 0;

   while (iAli != alignables.end() && iParamSel != paramSels.end()) {
     std::vector<bool> boolParSel;
     bool charSelIsGeneral = this->decodeParamSel(*iParamSel, boolParSel);
     if (this->add(*iAli, boolParSel)) ++nHigherLevel;
     if (charSelIsGeneral) this->addFullParamSel((*iAli)->alignmentParameters(), *iParamSel);

     ++iAli;
     ++iParamSel;
   }

   edm::LogInfo("Alignment") << "@SUB=AlignmentParameterBuilder::addSelections"
                             << " Added " << addedSets << " set(s) of alignables with "
                             << theAlignables.size() << " alignables in total,"
                             << " of which " << nHigherLevel << " are higher level.";
   
   return addedSets;
}

//__________________________________________________________________________________________________
bool AlignmentParameterBuilder::add(Alignable *alignable, const std::vector<bool> &sel)
{ 

  AlgebraicVector par(RigidBodyAlignmentParameters::N_PARAM, 0);
  AlgebraicSymMatrix cov(RigidBodyAlignmentParameters::N_PARAM, 0);
  bool isHigherLevel = false;
 
  AlignableDet *alidet = dynamic_cast<AlignableDet*>(alignable);
  AlignmentParameters *paras = 0;
  if (alidet != 0) { // alignable Det
    paras = new RigidBodyAlignmentParameters(alignable, par, cov, sel);
  } else { // higher level object
    paras = new CompositeRigidBodyAlignmentParameters(alignable, par, cov, sel);
    isHigherLevel = true;
  }

  alignable->setAlignmentParameters(paras);
  theAlignables.push_back(alignable);

  return isHigherLevel;
}


//__________________________________________________________________________________________________
unsigned int AlignmentParameterBuilder::add(const std::vector<Alignable*> &alignables,
                                            const std::vector<bool> &sel)
{

  unsigned int nHigherLevel = 0;

  for (std::vector<Alignable*>::const_iterator iAli = alignables.begin();
       iAli != alignables.end(); ++iAli) {
    if (this->add(*iAli, sel)) ++nHigherLevel;
  }

  return nHigherLevel;
}


//__________________________________________________________________________________________________
void AlignmentParameterBuilder::fixAlignables(int n)
{

  if (n<1 || n>3) {
    edm::LogError("BadArgument") << " n = " << n << " is not in [1,3]";
    return;
  }

  std::vector<Alignable*> theNewAlignables;
  int i=0;
  int imax = theAlignables.size();
  for ( std::vector<Alignable*>::const_iterator ia=theAlignables.begin();
        ia!=theAlignables.end();  ia++ ) 
        {
          i++;
          if ( n==1 && i>1 ) 
                theNewAlignables.push_back(*ia);
          else if ( n==2 && i>1 && i<imax ) 
                theNewAlignables.push_back(*ia);
          else if ( n==3 && i>2 && i<imax) 
                theNewAlignables.push_back(*ia);
        }

  theAlignables = theNewAlignables;

  edm::LogInfo("Alignment") << "@SUB=AlignmentParameterBuilder::fixAlignables"
                            << "removing " << n << " alignables, so that " 
                            << theAlignables.size() << " alignables left";
}

//__________________________________________________________________________________________________
bool AlignmentParameterBuilder::decodeParamSel(const std::vector<char> &paramSelChar,
                                               std::vector<bool> &result) const
{
  result.clear();
  bool anyNon01 = false;

  for (unsigned int pos = 0; pos < paramSelChar.size(); ++pos) {

    switch (paramSelChar[pos]) {
    default:
      anyNon01 = true;
      // no break;
    case '1':
      result.push_back(true);
      break;
    case '0':
      result.push_back(false);
      break;
    }
  }

  return anyNon01;
}

//__________________________________________________________________________________________________
bool AlignmentParameterBuilder::addFullParamSel(AlignmentParameters *aliParams,
                                                const std::vector<char> &fullSel) const
{
  if (!aliParams) return false;

  aliParams->setUserVariables(new SelectionUserVariables(fullSel));

  return true;
}
Revision:	1.12
Committed:	Thu Nov 30 10:08:26 2006 UTC (18 years, 5 months ago) by flucke
Content type:	text/plain
Branch:	MAIN
CVS Tags:	CMSSW_1_3_0_SLC4_pre1, CMSSW_1_3_0_pre1, V01-00-00, V00-08-01, V00-08-00
Changes since 1.11:	+45 -5 lines
Log Message:	Adjust to the new storage of vector<char> instead of vector<bool> in AlignmentParameterSelector. The character '0' is is interpreted as false (de-select parameter), all other characters select the correspondong parameter (true). In case any other character than '0' or '1' is found, the vector<char> is attached as user variable (new class SelectionUserVariables) to the AlignmentParameters for furterh interpretation in the algorithms.
#	User	Rev	Content
1	flucke	1.5	/** \file AlignableParameterBuilder.cc
2			*
3	flucke	1.12	* $Date: 2006/11/08 16:36:22 $
4			* $Revision: 1.11 $
5	flucke	1.5	*/
6
7	fronga	1.1	#include "FWCore/MessageLogger/interface/MessageLogger.h"
8	flucke	1.8	#include "FWCore/ParameterSet/interface/ParameterSet.h"
9
10	fronga	1.1	#include "Geometry/CommonDetAlgo/interface/AlgebraicObjects.h"
11			#include "Alignment/CommonAlignment/interface/Alignable.h"
12			#include "Alignment/CommonAlignment/interface/AlignableDet.h"
13
14			#include "Alignment/CommonAlignmentParametrization/interface/RigidBodyAlignmentParameters.h"
15			#include "Alignment/CommonAlignmentParametrization/interface/CompositeRigidBodyAlignmentParameters.h"
16
17	flucke	1.8	//#include "Alignment/TrackerAlignment/interface/AlignableTracker.h" not needed since only forwarded
18
19	flucke	1.9	#include "Alignment/CommonAlignmentAlgorithm/interface/AlignmentParameterSelector.h"
20	flucke	1.12	#include "Alignment/CommonAlignmentAlgorithm/interface/SelectionUserVariables.h"
21	flucke	1.8
22	fronga	1.1	// This class's header
23
24			#include "Alignment/CommonAlignmentAlgorithm/interface/AlignmentParameterBuilder.h"
25
26
27			//__________________________________________________________________________________________________
28	flucke	1.8	AlignmentParameterBuilder::AlignmentParameterBuilder(AlignableTracker* alignableTracker) :
29			theAlignables(), theAlignableTracker(alignableTracker)
30	fronga	1.1	{
31	flucke	1.8	}
32	fronga	1.1
33	flucke	1.8	//__________________________________________________________________________________________________
34			AlignmentParameterBuilder::AlignmentParameterBuilder(AlignableTracker* alignableTracker,
35			const edm::ParameterSet &pSet) :
36			theAlignables(), theAlignableTracker(alignableTracker)
37			{
38	fronga	1.11	this->addSelections(pSet.getParameter<edm::ParameterSet>("Selector"));
39	fronga	1.1	}
40
41			//__________________________________________________________________________________________________
42	flucke	1.8	unsigned int AlignmentParameterBuilder::addSelections(const edm::ParameterSet &pSet)
43			{
44
45	flucke	1.9	AlignmentParameterSelector selector(theAlignableTracker);
46			const unsigned int addedSets = selector.addSelections(pSet);
47	flucke	1.8
48	flucke	1.9	const std::vector<Alignable*> &alignables = selector.selectedAlignables();
49	flucke	1.12	const std::vector<std::vector<char> > &paramSels = selector.selectedParameters();
50	flucke	1.5
51	flucke	1.9	std::vector<Alignable*>::const_iterator iAli = alignables.begin();
52	flucke	1.12	std::vector<std::vector<char> >::const_iterator iParamSel = paramSels.begin();
53	flucke	1.9	unsigned int nHigherLevel = 0;
54
55			while (iAli != alignables.end() && iParamSel != paramSels.end()) {
56	flucke	1.12	std::vector<bool> boolParSel;
57			bool charSelIsGeneral = this->decodeParamSel(*iParamSel, boolParSel);
58			if (this->add(*iAli, boolParSel)) ++nHigherLevel;
59			if (charSelIsGeneral) this->addFullParamSel((iAli)->alignmentParameters(), iParamSel);
60
61	flucke	1.9	++iAli;
62			++iParamSel;
63	flucke	1.5	}
64
65	flucke	1.8	edm::LogInfo("Alignment") << "@SUB=AlignmentParameterBuilder::addSelections"
66	flucke	1.9	<< " Added " << addedSets << " set(s) of alignables with "
67			<< theAlignables.size() << " alignables in total,"
68			<< " of which " << nHigherLevel << " are higher level.";
69
70	flucke	1.8	return addedSets;
71	flucke	1.5	}
72
73			//__________________________________________________________________________________________________
74	flucke	1.9	bool AlignmentParameterBuilder::add(Alignable *alignable, const std::vector<bool> &sel)
75			{
76	flucke	1.5
77	flucke	1.9	AlgebraicVector par(RigidBodyAlignmentParameters::N_PARAM, 0);
78			AlgebraicSymMatrix cov(RigidBodyAlignmentParameters::N_PARAM, 0);
79			bool isHigherLevel = false;
80
81			AlignableDet alidet = dynamic_cast<AlignableDet>(alignable);
82			AlignmentParameters *paras = 0;
83			if (alidet != 0) { // alignable Det
84			paras = new RigidBodyAlignmentParameters(alignable, par, cov, sel);
85			} else { // higher level object
86			paras = new CompositeRigidBodyAlignmentParameters(alignable, par, cov, sel);
87			isHigherLevel = true;
88	flucke	1.5	}
89
90	flucke	1.9	alignable->setAlignmentParameters(paras);
91			theAlignables.push_back(alignable);
92
93			return isHigherLevel;
94	flucke	1.5	}
95
96
97			//__________________________________________________________________________________________________
98	flucke	1.9	unsigned int AlignmentParameterBuilder::add(const std::vector<Alignable*> &alignables,
99			const std::vector<bool> &sel)
100	flucke	1.5	{
101
102	flucke	1.9	unsigned int nHigherLevel = 0;
103	fronga	1.1
104	flucke	1.9	for (std::vector<Alignable*>::const_iterator iAli = alignables.begin();
105			iAli != alignables.end(); ++iAli) {
106			if (this->add(*iAli, sel)) ++nHigherLevel;
107	fronga	1.1	}
108
109	flucke	1.9	return nHigherLevel;
110	fronga	1.1	}
111
112
113			//__________________________________________________________________________________________________
114			void AlignmentParameterBuilder::fixAlignables(int n)
115			{
116
117	fpschill	1.3	if (n<1 \|\| n>3) {
118	flucke	1.5	edm::LogError("BadArgument") << " n = " << n << " is not in [1,3]";
119	fronga	1.1	return;
120			}
121
122			std::vector<Alignable*> theNewAlignables;
123			int i=0;
124			int imax = theAlignables.size();
125			for ( std::vector<Alignable*>::const_iterator ia=theAlignables.begin();
126			ia!=theAlignables.end(); ia++ )
127			{
128			i++;
129			if ( n==1 && i>1 )
130			theNewAlignables.push_back(*ia);
131			else if ( n==2 && i>1 && i<imax )
132			theNewAlignables.push_back(*ia);
133			else if ( n==3 && i>2 && i<imax)
134			theNewAlignables.push_back(*ia);
135			}
136
137			theAlignables = theNewAlignables;
138
139	flucke	1.10	edm::LogInfo("Alignment") << "@SUB=AlignmentParameterBuilder::fixAlignables"
140			<< "removing " << n << " alignables, so that "
141			<< theAlignables.size() << " alignables left";
142	fronga	1.1	}
143
144	flucke	1.12	//__________________________________________________________________________________________________
145			bool AlignmentParameterBuilder::decodeParamSel(const std::vector<char> &paramSelChar,
146			std::vector<bool> &result) const
147			{
148			result.clear();
149			bool anyNon01 = false;
150
151			for (unsigned int pos = 0; pos < paramSelChar.size(); ++pos) {
152
153			switch (paramSelChar[pos]) {
154			default:
155			anyNon01 = true;
156			// no break;
157			case '1':
158			result.push_back(true);
159			break;
160			case '0':
161			result.push_back(false);
162			break;
163			}
164			}
165
166			return anyNon01;
167			}
168
169			//__________________________________________________________________________________________________
170			bool AlignmentParameterBuilder::addFullParamSel(AlignmentParameters *aliParams,
171			const std::vector<char> &fullSel) const
172			{
173			if (!aliParams) return false;
174
175			aliParams->setUserVariables(new SelectionUserVariables(fullSel));
176
177			return true;
178			}