CommonAlignmentAlgorithm/src/AlignmentParameterBuilder.cc

/** \file AlignableParameterBuilder.cc
 *
 *  $Date: 2006/11/03 16:28:55 $
 *  $Revision: 1.8 $
 */

#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"

// 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>("AlignmentParameterSelector"));
}

//__________________________________________________________________________________________________
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<bool> > &paramSels = selector.selectedParameters();

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

   while (iAli != alignables.end() && iParamSel != paramSels.end()) {
     if (this->add(*iAli, *iParamSel)) ++nHigherLevel;
     ++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::LogWarning("Alignment") << "removing " << n 
                               << " alignables, so that " << theAlignables.size() 
                               << " alignables left";
  
}

Revision:	1.9
Committed:	Tue Nov 7 10:22:56 2006 UTC (18 years, 5 months ago) by flucke
Content type:	text/plain
Branch:	MAIN
Changes since 1.8:	+44 -154 lines
Log Message:	Completely decouple selection of Alignables AND their active parameters from building the requested AlignmentParameters by: - replacing AlignableSelector by AlignmentParameterSelector - moving decoding of selection of active parameters from AlignmentParameterBuilder to AlignmentParameterSelector
#	User	Rev	Content
1	flucke	1.5	/** \file AlignableParameterBuilder.cc
2			*
3	flucke	1.9	* $Date: 2006/11/03 16:28:55 $
4			* $Revision: 1.8 $
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.8
21	fronga	1.1	// This class's header
22
23			#include "Alignment/CommonAlignmentAlgorithm/interface/AlignmentParameterBuilder.h"
24
25
26			//__________________________________________________________________________________________________
27	flucke	1.8	AlignmentParameterBuilder::AlignmentParameterBuilder(AlignableTracker* alignableTracker) :
28			theAlignables(), theAlignableTracker(alignableTracker)
29	fronga	1.1	{
30	flucke	1.8	}
31	fronga	1.1
32	flucke	1.8	//__________________________________________________________________________________________________
33			AlignmentParameterBuilder::AlignmentParameterBuilder(AlignableTracker* alignableTracker,
34			const edm::ParameterSet &pSet) :
35			theAlignables(), theAlignableTracker(alignableTracker)
36			{
37	flucke	1.9	this->addSelections(pSet.getParameter<edm::ParameterSet>("AlignmentParameterSelector"));
38	fronga	1.1	}
39
40			//__________________________________________________________________________________________________
41	flucke	1.8	unsigned int AlignmentParameterBuilder::addSelections(const edm::ParameterSet &pSet)
42			{
43
44	flucke	1.9	AlignmentParameterSelector selector(theAlignableTracker);
45			const unsigned int addedSets = selector.addSelections(pSet);
46	flucke	1.8
47	flucke	1.9	const std::vector<Alignable*> &alignables = selector.selectedAlignables();
48			const std::vector<std::vector<bool> > &paramSels = selector.selectedParameters();
49	flucke	1.5
50	flucke	1.9	std::vector<Alignable*>::const_iterator iAli = alignables.begin();
51			std::vector<std::vector<bool> >::const_iterator iParamSel = paramSels.begin();
52			unsigned int nHigherLevel = 0;
53
54			while (iAli != alignables.end() && iParamSel != paramSels.end()) {
55			if (this->add(iAli, iParamSel)) ++nHigherLevel;
56			++iAli;
57			++iParamSel;
58	flucke	1.5	}
59
60	flucke	1.8	edm::LogInfo("Alignment") << "@SUB=AlignmentParameterBuilder::addSelections"
61	flucke	1.9	<< " Added " << addedSets << " set(s) of alignables with "
62			<< theAlignables.size() << " alignables in total,"
63			<< " of which " << nHigherLevel << " are higher level.";
64
65	flucke	1.8	return addedSets;
66	flucke	1.5	}
67
68			//__________________________________________________________________________________________________
69	flucke	1.9	bool AlignmentParameterBuilder::add(Alignable *alignable, const std::vector<bool> &sel)
70			{
71	flucke	1.5
72	flucke	1.9	AlgebraicVector par(RigidBodyAlignmentParameters::N_PARAM, 0);
73			AlgebraicSymMatrix cov(RigidBodyAlignmentParameters::N_PARAM, 0);
74			bool isHigherLevel = false;
75
76			AlignableDet alidet = dynamic_cast<AlignableDet>(alignable);
77			AlignmentParameters *paras = 0;
78			if (alidet != 0) { // alignable Det
79			paras = new RigidBodyAlignmentParameters(alignable, par, cov, sel);
80			} else { // higher level object
81			paras = new CompositeRigidBodyAlignmentParameters(alignable, par, cov, sel);
82			isHigherLevel = true;
83	flucke	1.5	}
84
85	flucke	1.9	alignable->setAlignmentParameters(paras);
86			theAlignables.push_back(alignable);
87
88			return isHigherLevel;
89	flucke	1.5	}
90
91
92			//__________________________________________________________________________________________________
93	flucke	1.9	unsigned int AlignmentParameterBuilder::add(const std::vector<Alignable*> &alignables,
94			const std::vector<bool> &sel)
95	flucke	1.5	{
96
97	flucke	1.9	unsigned int nHigherLevel = 0;
98	fronga	1.1
99	flucke	1.9	for (std::vector<Alignable*>::const_iterator iAli = alignables.begin();
100			iAli != alignables.end(); ++iAli) {
101			if (this->add(*iAli, sel)) ++nHigherLevel;
102	fronga	1.1	}
103
104	flucke	1.9	return nHigherLevel;
105	fronga	1.1	}
106
107
108			//__________________________________________________________________________________________________
109			void AlignmentParameterBuilder::fixAlignables(int n)
110			{
111
112	fpschill	1.3	if (n<1 \|\| n>3) {
113	flucke	1.5	edm::LogError("BadArgument") << " n = " << n << " is not in [1,3]";
114	fronga	1.1	return;
115			}
116
117			std::vector<Alignable*> theNewAlignables;
118			int i=0;
119			int imax = theAlignables.size();
120			for ( std::vector<Alignable*>::const_iterator ia=theAlignables.begin();
121			ia!=theAlignables.end(); ia++ )
122			{
123			i++;
124			if ( n==1 && i>1 )
125			theNewAlignables.push_back(*ia);
126			else if ( n==2 && i>1 && i<imax )
127			theNewAlignables.push_back(*ia);
128			else if ( n==3 && i>2 && i<imax)
129			theNewAlignables.push_back(*ia);
130			}
131
132			theAlignables = theNewAlignables;
133
134	fpschill	1.3	edm::LogWarning("Alignment") << "removing " << n
135	flucke	1.5	<< " alignables, so that " << theAlignables.size()
136			<< " alignables left";
137	fronga	1.1
138			}
139