CommonAlignmentAlgorithm/src/AlignmentParameterBuilder.cc

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

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

// This class's header

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


//__________________________________________________________________________________________________
AlignmentParameterBuilder::AlignmentParameterBuilder( AlignableTracker* alignableTracker )
{

  theAlignableTracker = alignableTracker;

  theTrackerAlignableId = new TrackerAlignableId();
  theOnlyDS=false;
  theOnlySS=false;
  theSelLayers=false;
  theMinLayer=-1;
  theMaxLayer=999;

}

//__________________________________________________________________________________________________
void AlignmentParameterBuilder::addSelection(const std::string &name, const std::vector<bool> &sel)
{

  edm::LogWarning("Alignment") << "[AlignmentParameterBuilder] Called for selection >" << name<<"<";

  if      (name == "AllDets")       addAllDets(sel);
  else if (name == "AllRods")       addAllRods(sel);
  else if (name == "AllLayers")     addAllLayers(sel);
  else if (name == "AllComponents") addAllComponents(sel);
  else if (name == "AllAlignables") addAllAlignables(sel);

  // TIB+TOB
  else if (name == "BarrelRods")    add(theAlignableTracker->barrelRods(),sel);
  else if (name == "BarrelDets")    add(theAlignableTracker->barrelGeomDets(),sel);
  else if (name == "BarrelLayers")  add(theAlignableTracker->barrelLayers(),sel);

  else if (name == "BarrelDSRods")  
        {
          theOnlyDS = true;
          add( theAlignableTracker->barrelRods(), sel );
          theOnlyDS = false;
        }

  // PXBarrel
  else if (name == "PixelHalfBarrelDets")
        add(theAlignableTracker->pixelHalfBarrelGeomDets(),sel);
  else if (name == "PixelHalfBarrelLadders") 
        add(theAlignableTracker->pixelHalfBarrelLadders(),sel);
  else if (name == "PixelHalfBarrelLayers")  
        add(theAlignableTracker->pixelHalfBarrelLayers(),sel);

  else if (name == "PixelHalfBarrelLaddersLayers12") {
    theSelLayers=true; theMinLayer=1; theMaxLayer=2;
    add(theAlignableTracker->pixelHalfBarrelLadders(),sel);
  }


  // PXEndcap
  else if (name == "PXECDets")      add(theAlignableTracker->pixelEndcapGeomDets(),sel);
  else if (name == "PXECPetals")    add(theAlignableTracker->pixelEndcapPetals(),sel);
  else if (name == "PXECLayers")    add(theAlignableTracker->pixelEndcapLayers(),sel);

  // Pixel Barrel+endcap
  else if (name == "PixelDets") {
    add(theAlignableTracker->pixelHalfBarrelGeomDets(),sel);
    add(theAlignableTracker->pixelEndcapGeomDets(),sel);
  }
  else if (name == "PixelRods") {
    add(theAlignableTracker->pixelHalfBarrelLadders(),sel);
    add(theAlignableTracker->pixelEndcapPetals(),sel);
  }
  else if (name == "PixelLayers") {
    add(theAlignableTracker->pixelHalfBarrelLayers(),sel);
    add(theAlignableTracker->pixelEndcapLayers(),sel);
  }

  // TID
  else if (name == "TIDLayers")     add(theAlignableTracker->TIDLayers(),sel);
  else if (name == "TIDRings")      add(theAlignableTracker->TIDRings(),sel);
  else if (name == "TIDDets")       add(theAlignableTracker->TIDGeomDets(),sel);

  // TEC
  else if (name == "TECDets")       add(theAlignableTracker->endcapGeomDets(),sel); 
  else if (name == "TECPetals")     add(theAlignableTracker->endcapPetals(),sel);
  else if (name == "TECLayers")     add(theAlignableTracker->endcapLayers(),sel);

  // StripEndcap (TID+TEC)
  else if (name == "EndcapDets") {
    add(theAlignableTracker->TIDGeomDets(),sel);
    add(theAlignableTracker->endcapGeomDets(),sel); 
  }
  else if (name == "EndcapPetals") {
    add(theAlignableTracker->TIDRings(),sel);
    add(theAlignableTracker->endcapPetals(),sel);
  }
  else if (name == "EndcapLayers") {
    add(theAlignableTracker->TIDLayers(),sel);
    add(theAlignableTracker->endcapLayers(),sel);
  }

  // Strip Barrel+endcap
  else if (name == "StripDets") {
    add(theAlignableTracker->barrelGeomDets(),sel);
    add(theAlignableTracker->TIDGeomDets(),sel);
    add(theAlignableTracker->endcapGeomDets(),sel); 
  }
  else if (name == "StripRods") {
    add(theAlignableTracker->barrelRods(),sel);
    add(theAlignableTracker->TIDRings(),sel);
    add(theAlignableTracker->endcapPetals(),sel);
  }
  else if (name == "StripLayers") {
    add(theAlignableTracker->barrelLayers(),sel);
    add(theAlignableTracker->TIDLayers(),sel);
    add(theAlignableTracker->endcapLayers(),sel);
  }


  // Custom scenarios

  else if (name == "ScenarioA") {
        std::vector<bool> mysel(6,false);
    // pixel barrel dets x,y,z
    mysel[RigidBodyAlignmentParameters::dx]=true;
    mysel[RigidBodyAlignmentParameters::dy]=true;
    mysel[RigidBodyAlignmentParameters::dz]=true;
    add(theAlignableTracker->pixelHalfBarrelGeomDets(),mysel);
    // strip barrel double sided
    theOnlyDS = true;
    add(theAlignableTracker->barrelRods(),mysel);
    theOnlyDS = false;
    // strip barrel single sided
    mysel[RigidBodyAlignmentParameters::dy]=false;
    theOnlySS = true;
    add(theAlignableTracker->barrelRods(),mysel);
    theOnlySS = false;
  }

  else if (name == "ScenarioB") {
        std::vector<bool> mysel(6,false);
    // pixel barrel ladders x,y,z
    mysel[RigidBodyAlignmentParameters::dx]=true;
    mysel[RigidBodyAlignmentParameters::dy]=true;
    mysel[RigidBodyAlignmentParameters::dz]=true;
    add(theAlignableTracker->pixelHalfBarrelLadders(),mysel);
    // strip barrel layers double sided
    theOnlyDS = true;
    add(theAlignableTracker->barrelLayers(),mysel);
    theOnlyDS = false;
    // strip barrel layers single sided
    mysel[RigidBodyAlignmentParameters::dy]=false;
    theOnlySS = true;
    add(theAlignableTracker->barrelLayers(),mysel);
    theOnlySS = false;
  }


  else if (name == "CustomStripLayers") {
        std::vector<bool> mysel(6,false);
    mysel[RigidBodyAlignmentParameters::dx]=true;
    mysel[RigidBodyAlignmentParameters::dy]=true;
    mysel[RigidBodyAlignmentParameters::dz]=true;
    // strip barrel layers double sided
    theOnlyDS = true;
    add(theAlignableTracker->barrelLayers(),mysel);
    theOnlyDS = false;
    // strip barrel layers single sided
    mysel[RigidBodyAlignmentParameters::dz]=false;
    theOnlySS = true;
    add(theAlignableTracker->barrelLayers(),mysel);
    theOnlySS = false;
    // TID
    mysel[RigidBodyAlignmentParameters::dz]=true;
    add(theAlignableTracker->TIDLayers(),mysel);
    // TEC
    mysel[RigidBodyAlignmentParameters::dz]=false;
    add(theAlignableTracker->endcapLayers(),mysel);
  }

  else if (name == "CustomStripRods") {
        std::vector<bool> mysel(6,false);
    mysel[RigidBodyAlignmentParameters::dx]=true;
    mysel[RigidBodyAlignmentParameters::dy]=true;
    mysel[RigidBodyAlignmentParameters::dz]=true;
    // strip barrel layers double sided
    theOnlyDS = true;
    add(theAlignableTracker->barrelRods(),mysel);
    theOnlyDS = false;
    // strip barrel layers single sided
    mysel[RigidBodyAlignmentParameters::dy]=false;
    theOnlySS = true;
    add(theAlignableTracker->barrelRods(),mysel);
    theOnlySS = false;
    // TID
    mysel[RigidBodyAlignmentParameters::dy]=true;
    add(theAlignableTracker->TIDRings(),mysel);
    // TEC
    mysel[RigidBodyAlignmentParameters::dz]=false;
    add(theAlignableTracker->endcapPetals(),mysel);
  }

  else 
    edm::LogError("BadConfig")<<"[AlignmentParameterBuilder] Selection invalid!";

  edm::LogInfo("Warning") << "[AlignmentParameterBuilder] Added " 
    << theAlignables.size()<< " alignables in total";

}


//__________________________________________________________________________________________________
void AlignmentParameterBuilder::addAllDets(const std::vector<bool> &sel)
{

  add(theAlignableTracker->barrelGeomDets(),sel);          // TIB+TOB
  add(theAlignableTracker->endcapGeomDets(),sel);          // TEC
  add(theAlignableTracker->TIDGeomDets(),sel);             // TID
  add(theAlignableTracker->pixelHalfBarrelGeomDets(),sel); // PixelBarrel
  add(theAlignableTracker->pixelEndcapGeomDets(),sel);     // PixelEndcap

  edm::LogInfo("Alignment") << "Initialized for "
                                                                                        << theAlignables.size() << " dets";
}


//__________________________________________________________________________________________________
void AlignmentParameterBuilder::addAllRods(const std::vector<bool> &sel)
{
  add(theAlignableTracker->barrelRods(),sel);
  add(theAlignableTracker->pixelHalfBarrelLadders(),sel);
  add(theAlignableTracker->endcapPetals(),sel);
  add(theAlignableTracker->TIDRings(),sel);
  add(theAlignableTracker->pixelEndcapPetals(),sel);

  edm::LogInfo("Alignment") << "Initialized for "
                                                                                        << theAlignables.size() << " rods";
}


//__________________________________________________________________________________________________
void AlignmentParameterBuilder::addAllLayers(const std::vector<bool> &sel)
{
  add(theAlignableTracker->barrelLayers(),sel);
  add(theAlignableTracker->pixelHalfBarrelLayers(),sel);
  add(theAlignableTracker->endcapLayers(),sel);
  add(theAlignableTracker->TIDLayers(),sel);
  add(theAlignableTracker->pixelEndcapLayers(),sel);

  edm::LogInfo("Alignment") << "Initialized for "
                                                                                        << theAlignables.size() << " layers";

}


//__________________________________________________________________________________________________
void AlignmentParameterBuilder::addAllComponents(const std::vector<bool> &sel)
{
  add(theAlignableTracker->components(),sel);
  edm::LogInfo("Alignment") << "Initialized for "
                                                                                        << theAlignables.size() 
                                                                                        << " Components (HalfBarrel/Endcap)";
}


//__________________________________________________________________________________________________
void AlignmentParameterBuilder::addAllAlignables(const std::vector<bool> &sel)
{

  add(theAlignableTracker->barrelGeomDets(),sel);          
  add(theAlignableTracker->endcapGeomDets(),sel);          
  add(theAlignableTracker->TIDGeomDets(),sel);             
  add(theAlignableTracker->pixelHalfBarrelGeomDets(),sel); 
  add(theAlignableTracker->pixelEndcapGeomDets(),sel);     

  add(theAlignableTracker->barrelRods(),sel);
  add(theAlignableTracker->pixelHalfBarrelLadders(),sel);
  add(theAlignableTracker->endcapPetals(),sel);
  add(theAlignableTracker->TIDRings(),sel);
  add(theAlignableTracker->pixelEndcapPetals(),sel);

  add(theAlignableTracker->barrelLayers(),sel);
  add(theAlignableTracker->pixelHalfBarrelLayers(),sel);
  add(theAlignableTracker->endcapLayers(),sel);
  add(theAlignableTracker->TIDLayers(),sel);
  add(theAlignableTracker->pixelEndcapLayers(),sel);

  add(theAlignableTracker->components(),sel);


  edm::LogInfo("Alignment") << "Initialized for "
                                                                                        << theAlignables.size() 
                                                                                        << " Components (HalfBarrel/Endcap)";

}


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

  int num_adu = 0;
  int num_det = 0;
  int num_hlo = 0;

  // loop on Alignable objects
  for ( std::vector<Alignable*>::const_iterator ia=alignables.begin();
        ia!=alignables.end();  ia++ ) {
    Alignable* ali=(*ia);

    // select on single/double sided barrel layers
        std::pair<int,int> tl=theTrackerAlignableId->typeAndLayerFromAlignable( ali );
    int type = tl.first;
    int layer = tl.second;

    bool keep=true;
    if (theOnlySS) // only single sided
      if ( (abs(type)==3 || abs(type)==5) && layer<2 ) 
                keep=false;

    if (theOnlyDS) // only double sided
      if ( (abs(type)==3 || abs(type)==5) && layer>1 )
                keep=false;

    // reject layers
    if ( theSelLayers && (layer<theMinLayer || layer>theMaxLayer) )  
          keep=false;


    if (keep) {

          AlgebraicVector par(6,0);
          AlgebraicSymMatrix cov(6,0);

          AlignableDet* alidet = dynamic_cast<AlignableDet*>(ali);
          if (alidet !=0) { // alignable Det
                RigidBodyAlignmentParameters* dap = 
                  new RigidBodyAlignmentParameters(ali,par,cov,sel);
                ali->setAlignmentParameters(dap);
                num_det++;
          } else { // higher level object
                CompositeRigidBodyAlignmentParameters* dap = 
                  new CompositeRigidBodyAlignmentParameters(ali,par,cov,sel);
                ali->setAlignmentParameters(dap);
                num_hlo++;
          }

          theAlignables.push_back(ali);
          num_adu++;

    }
  }

  edm::LogWarning("Alignment") << "Added " << num_adu 
    << " Alignables, of which " << num_det << " are Dets and "
    << num_hlo << " are higher level.";

}


//__________________________________________________________________________________________________
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.4
Committed:	Tue Oct 17 16:03:09 2006 UTC (18 years, 6 months ago) by flucke
Content type:	text/plain
Branch:	MAIN
CVS Tags:	V00-03-00
Changes since 1.3:	+10 -11 lines
Log Message:	arguments by const reference
#	User	Rev	Content
1	fronga	1.1	#include "FWCore/MessageLogger/interface/MessageLogger.h"
2			#include "Geometry/CommonDetAlgo/interface/AlgebraicObjects.h"
3			#include "Alignment/CommonAlignment/interface/Alignable.h"
4			#include "Alignment/CommonAlignment/interface/AlignableDet.h"
5			#include "Alignment/CommonAlignment/interface/AlignableComposite.h"
6
7			#include "Alignment/CommonAlignmentParametrization/interface/RigidBodyAlignmentParameters.h"
8			#include "Alignment/CommonAlignmentParametrization/interface/CompositeRigidBodyAlignmentParameters.h"
9
10			// This class's header
11
12			#include "Alignment/CommonAlignmentAlgorithm/interface/AlignmentParameterBuilder.h"
13
14
15			//__________________________________________________________________________________________________
16			AlignmentParameterBuilder::AlignmentParameterBuilder( AlignableTracker* alignableTracker )
17			{
18
19			theAlignableTracker = alignableTracker;
20
21			theTrackerAlignableId = new TrackerAlignableId();
22			theOnlyDS=false;
23			theOnlySS=false;
24			theSelLayers=false;
25			theMinLayer=-1;
26			theMaxLayer=999;
27
28			}
29
30			//__________________________________________________________________________________________________
31	flucke	1.4	void AlignmentParameterBuilder::addSelection(const std::string &name, const std::vector<bool> &sel)
32	fronga	1.1	{
33
34	fpschill	1.3	edm::LogWarning("Alignment") << "[AlignmentParameterBuilder] Called for selection >" << name<<"<";
35	fronga	1.1
36			if (name == "AllDets") addAllDets(sel);
37			else if (name == "AllRods") addAllRods(sel);
38			else if (name == "AllLayers") addAllLayers(sel);
39			else if (name == "AllComponents") addAllComponents(sel);
40			else if (name == "AllAlignables") addAllAlignables(sel);
41
42			// TIB+TOB
43			else if (name == "BarrelRods") add(theAlignableTracker->barrelRods(),sel);
44			else if (name == "BarrelDets") add(theAlignableTracker->barrelGeomDets(),sel);
45			else if (name == "BarrelLayers") add(theAlignableTracker->barrelLayers(),sel);
46
47			else if (name == "BarrelDSRods")
48			{
49			theOnlyDS = true;
50			add( theAlignableTracker->barrelRods(), sel );
51			theOnlyDS = false;
52			}
53
54			// PXBarrel
55			else if (name == "PixelHalfBarrelDets")
56			add(theAlignableTracker->pixelHalfBarrelGeomDets(),sel);
57			else if (name == "PixelHalfBarrelLadders")
58			add(theAlignableTracker->pixelHalfBarrelLadders(),sel);
59			else if (name == "PixelHalfBarrelLayers")
60			add(theAlignableTracker->pixelHalfBarrelLayers(),sel);
61
62			else if (name == "PixelHalfBarrelLaddersLayers12") {
63			theSelLayers=true; theMinLayer=1; theMaxLayer=2;
64			add(theAlignableTracker->pixelHalfBarrelLadders(),sel);
65			}
66
67
68			// PXEndcap
69			else if (name == "PXECDets") add(theAlignableTracker->pixelEndcapGeomDets(),sel);
70			else if (name == "PXECPetals") add(theAlignableTracker->pixelEndcapPetals(),sel);
71			else if (name == "PXECLayers") add(theAlignableTracker->pixelEndcapLayers(),sel);
72
73			// Pixel Barrel+endcap
74			else if (name == "PixelDets") {
75			add(theAlignableTracker->pixelHalfBarrelGeomDets(),sel);
76			add(theAlignableTracker->pixelEndcapGeomDets(),sel);
77			}
78			else if (name == "PixelRods") {
79			add(theAlignableTracker->pixelHalfBarrelLadders(),sel);
80			add(theAlignableTracker->pixelEndcapPetals(),sel);
81			}
82			else if (name == "PixelLayers") {
83			add(theAlignableTracker->pixelHalfBarrelLayers(),sel);
84			add(theAlignableTracker->pixelEndcapLayers(),sel);
85			}
86
87			// TID
88			else if (name == "TIDLayers") add(theAlignableTracker->TIDLayers(),sel);
89			else if (name == "TIDRings") add(theAlignableTracker->TIDRings(),sel);
90			else if (name == "TIDDets") add(theAlignableTracker->TIDGeomDets(),sel);
91
92			// TEC
93			else if (name == "TECDets") add(theAlignableTracker->endcapGeomDets(),sel);
94			else if (name == "TECPetals") add(theAlignableTracker->endcapPetals(),sel);
95			else if (name == "TECLayers") add(theAlignableTracker->endcapLayers(),sel);
96
97			// StripEndcap (TID+TEC)
98			else if (name == "EndcapDets") {
99			add(theAlignableTracker->TIDGeomDets(),sel);
100			add(theAlignableTracker->endcapGeomDets(),sel);
101			}
102			else if (name == "EndcapPetals") {
103			add(theAlignableTracker->TIDRings(),sel);
104			add(theAlignableTracker->endcapPetals(),sel);
105			}
106			else if (name == "EndcapLayers") {
107			add(theAlignableTracker->TIDLayers(),sel);
108			add(theAlignableTracker->endcapLayers(),sel);
109			}
110
111			// Strip Barrel+endcap
112			else if (name == "StripDets") {
113			add(theAlignableTracker->barrelGeomDets(),sel);
114			add(theAlignableTracker->TIDGeomDets(),sel);
115			add(theAlignableTracker->endcapGeomDets(),sel);
116			}
117			else if (name == "StripRods") {
118			add(theAlignableTracker->barrelRods(),sel);
119			add(theAlignableTracker->TIDRings(),sel);
120			add(theAlignableTracker->endcapPetals(),sel);
121			}
122			else if (name == "StripLayers") {
123			add(theAlignableTracker->barrelLayers(),sel);
124			add(theAlignableTracker->TIDLayers(),sel);
125			add(theAlignableTracker->endcapLayers(),sel);
126			}
127
128
129			// Custom scenarios
130
131			else if (name == "ScenarioA") {
132			std::vector<bool> mysel(6,false);
133			// pixel barrel dets x,y,z
134			mysel[RigidBodyAlignmentParameters::dx]=true;
135			mysel[RigidBodyAlignmentParameters::dy]=true;
136			mysel[RigidBodyAlignmentParameters::dz]=true;
137			add(theAlignableTracker->pixelHalfBarrelGeomDets(),mysel);
138			// strip barrel double sided
139			theOnlyDS = true;
140			add(theAlignableTracker->barrelRods(),mysel);
141			theOnlyDS = false;
142			// strip barrel single sided
143			mysel[RigidBodyAlignmentParameters::dy]=false;
144			theOnlySS = true;
145			add(theAlignableTracker->barrelRods(),mysel);
146			theOnlySS = false;
147			}
148
149			else if (name == "ScenarioB") {
150			std::vector<bool> mysel(6,false);
151			// pixel barrel ladders x,y,z
152			mysel[RigidBodyAlignmentParameters::dx]=true;
153			mysel[RigidBodyAlignmentParameters::dy]=true;
154			mysel[RigidBodyAlignmentParameters::dz]=true;
155			add(theAlignableTracker->pixelHalfBarrelLadders(),mysel);
156			// strip barrel layers double sided
157			theOnlyDS = true;
158			add(theAlignableTracker->barrelLayers(),mysel);
159			theOnlyDS = false;
160			// strip barrel layers single sided
161			mysel[RigidBodyAlignmentParameters::dy]=false;
162			theOnlySS = true;
163			add(theAlignableTracker->barrelLayers(),mysel);
164			theOnlySS = false;
165			}
166
167
168			else if (name == "CustomStripLayers") {
169			std::vector<bool> mysel(6,false);
170			mysel[RigidBodyAlignmentParameters::dx]=true;
171			mysel[RigidBodyAlignmentParameters::dy]=true;
172			mysel[RigidBodyAlignmentParameters::dz]=true;
173			// strip barrel layers double sided
174			theOnlyDS = true;
175			add(theAlignableTracker->barrelLayers(),mysel);
176			theOnlyDS = false;
177			// strip barrel layers single sided
178			mysel[RigidBodyAlignmentParameters::dz]=false;
179			theOnlySS = true;
180			add(theAlignableTracker->barrelLayers(),mysel);
181			theOnlySS = false;
182			// TID
183			mysel[RigidBodyAlignmentParameters::dz]=true;
184			add(theAlignableTracker->TIDLayers(),mysel);
185			// TEC
186			mysel[RigidBodyAlignmentParameters::dz]=false;
187			add(theAlignableTracker->endcapLayers(),mysel);
188			}
189
190			else if (name == "CustomStripRods") {
191			std::vector<bool> mysel(6,false);
192			mysel[RigidBodyAlignmentParameters::dx]=true;
193			mysel[RigidBodyAlignmentParameters::dy]=true;
194			mysel[RigidBodyAlignmentParameters::dz]=true;
195			// strip barrel layers double sided
196			theOnlyDS = true;
197			add(theAlignableTracker->barrelRods(),mysel);
198			theOnlyDS = false;
199			// strip barrel layers single sided
200			mysel[RigidBodyAlignmentParameters::dy]=false;
201			theOnlySS = true;
202			add(theAlignableTracker->barrelRods(),mysel);
203			theOnlySS = false;
204			// TID
205			mysel[RigidBodyAlignmentParameters::dy]=true;
206			add(theAlignableTracker->TIDRings(),mysel);
207			// TEC
208			mysel[RigidBodyAlignmentParameters::dz]=false;
209			add(theAlignableTracker->endcapPetals(),mysel);
210			}
211
212			else
213	fpschill	1.3	edm::LogError("BadConfig")<<"[AlignmentParameterBuilder] Selection invalid!";
214	fronga	1.1
215	fpschill	1.3	edm::LogInfo("Warning") << "[AlignmentParameterBuilder] Added "
216			<< theAlignables.size()<< " alignables in total";
217	fronga	1.1
218			}
219
220
221			//__________________________________________________________________________________________________
222	flucke	1.4	void AlignmentParameterBuilder::addAllDets(const std::vector<bool> &sel)
223	fronga	1.1	{
224
225			add(theAlignableTracker->barrelGeomDets(),sel); // TIB+TOB
226			add(theAlignableTracker->endcapGeomDets(),sel); // TEC
227			add(theAlignableTracker->TIDGeomDets(),sel); // TID
228			add(theAlignableTracker->pixelHalfBarrelGeomDets(),sel); // PixelBarrel
229			add(theAlignableTracker->pixelEndcapGeomDets(),sel); // PixelEndcap
230
231	fpschill	1.3	edm::LogInfo("Alignment") << "Initialized for "
232	fronga	1.1	<< theAlignables.size() << " dets";
233			}
234
235
236			//__________________________________________________________________________________________________
237	flucke	1.4	void AlignmentParameterBuilder::addAllRods(const std::vector<bool> &sel)
238	fronga	1.1	{
239			add(theAlignableTracker->barrelRods(),sel);
240			add(theAlignableTracker->pixelHalfBarrelLadders(),sel);
241			add(theAlignableTracker->endcapPetals(),sel);
242			add(theAlignableTracker->TIDRings(),sel);
243			add(theAlignableTracker->pixelEndcapPetals(),sel);
244
245	fpschill	1.3	edm::LogInfo("Alignment") << "Initialized for "
246	fronga	1.1	<< theAlignables.size() << " rods";
247			}
248
249
250			//__________________________________________________________________________________________________
251	flucke	1.4	void AlignmentParameterBuilder::addAllLayers(const std::vector<bool> &sel)
252	fronga	1.1	{
253			add(theAlignableTracker->barrelLayers(),sel);
254			add(theAlignableTracker->pixelHalfBarrelLayers(),sel);
255			add(theAlignableTracker->endcapLayers(),sel);
256			add(theAlignableTracker->TIDLayers(),sel);
257			add(theAlignableTracker->pixelEndcapLayers(),sel);
258
259	fpschill	1.3	edm::LogInfo("Alignment") << "Initialized for "
260	fronga	1.1	<< theAlignables.size() << " layers";
261
262			}
263
264
265			//__________________________________________________________________________________________________
266	flucke	1.4	void AlignmentParameterBuilder::addAllComponents(const std::vector<bool> &sel)
267	fronga	1.1	{
268			add(theAlignableTracker->components(),sel);
269	fpschill	1.3	edm::LogInfo("Alignment") << "Initialized for "
270	fronga	1.1	<< theAlignables.size()
271			<< " Components (HalfBarrel/Endcap)";
272			}
273
274
275			//__________________________________________________________________________________________________
276	flucke	1.4	void AlignmentParameterBuilder::addAllAlignables(const std::vector<bool> &sel)
277	fronga	1.1	{
278
279			add(theAlignableTracker->barrelGeomDets(),sel);
280			add(theAlignableTracker->endcapGeomDets(),sel);
281			add(theAlignableTracker->TIDGeomDets(),sel);
282			add(theAlignableTracker->pixelHalfBarrelGeomDets(),sel);
283			add(theAlignableTracker->pixelEndcapGeomDets(),sel);
284
285			add(theAlignableTracker->barrelRods(),sel);
286			add(theAlignableTracker->pixelHalfBarrelLadders(),sel);
287			add(theAlignableTracker->endcapPetals(),sel);
288			add(theAlignableTracker->TIDRings(),sel);
289			add(theAlignableTracker->pixelEndcapPetals(),sel);
290
291			add(theAlignableTracker->barrelLayers(),sel);
292			add(theAlignableTracker->pixelHalfBarrelLayers(),sel);
293			add(theAlignableTracker->endcapLayers(),sel);
294			add(theAlignableTracker->TIDLayers(),sel);
295			add(theAlignableTracker->pixelEndcapLayers(),sel);
296
297			add(theAlignableTracker->components(),sel);
298
299
300	fpschill	1.3	edm::LogInfo("Alignment") << "Initialized for "
301	fronga	1.1	<< theAlignables.size()
302			<< " Components (HalfBarrel/Endcap)";
303
304			}
305
306
307			//__________________________________________________________________________________________________
308	flucke	1.4	void AlignmentParameterBuilder::add(const std::vector<Alignable*> &alignables,
309			const std::vector<bool> &sel)
310	fronga	1.1	{
311
312			int num_adu = 0;
313			int num_det = 0;
314			int num_hlo = 0;
315
316			// loop on Alignable objects
317			for ( std::vector<Alignable*>::const_iterator ia=alignables.begin();
318			ia!=alignables.end(); ia++ ) {
319			Alignable* ali=(*ia);
320
321			// select on single/double sided barrel layers
322			std::pair<int,int> tl=theTrackerAlignableId->typeAndLayerFromAlignable( ali );
323			int type = tl.first;
324			int layer = tl.second;
325
326			bool keep=true;
327			if (theOnlySS) // only single sided
328			if ( (abs(type)==3 \|\| abs(type)==5) && layer<2 )
329			keep=false;
330
331			if (theOnlyDS) // only double sided
332			if ( (abs(type)==3 \|\| abs(type)==5) && layer>1 )
333			keep=false;
334
335			// reject layers
336			if ( theSelLayers && (layer<theMinLayer \|\| layer>theMaxLayer) )
337			keep=false;
338
339
340			if (keep) {
341
342			AlgebraicVector par(6,0);
343			AlgebraicSymMatrix cov(6,0);
344
345			AlignableDet* alidet = dynamic_cast<AlignableDet*>(ali);
346			if (alidet !=0) { // alignable Det
347			RigidBodyAlignmentParameters* dap =
348			new RigidBodyAlignmentParameters(ali,par,cov,sel);
349	flucke	1.4	ali->setAlignmentParameters(dap);
350	fronga	1.1	num_det++;
351	flucke	1.4	} else { // higher level object
352	fronga	1.1	CompositeRigidBodyAlignmentParameters* dap =
353			new CompositeRigidBodyAlignmentParameters(ali,par,cov,sel);
354			ali->setAlignmentParameters(dap);
355			num_hlo++;
356			}
357
358			theAlignables.push_back(ali);
359			num_adu++;
360
361			}
362			}
363
364	fpschill	1.3	edm::LogWarning("Alignment") << "Added " << num_adu
365			<< " Alignables, of which " << num_det << " are Dets and "
366			<< num_hlo << " are higher level.";
367	fronga	1.1
368			}
369
370
371			//__________________________________________________________________________________________________
372			void AlignmentParameterBuilder::fixAlignables(int n)
373			{
374
375	fpschill	1.3	if (n<1 \|\| n>3) {
376			edm::LogError("BadArgument") << " n = " << n << " is not in [1,3]";
377	fronga	1.1	return;
378			}
379
380			std::vector<Alignable*> theNewAlignables;
381			int i=0;
382			int imax = theAlignables.size();
383			for ( std::vector<Alignable*>::const_iterator ia=theAlignables.begin();
384			ia!=theAlignables.end(); ia++ )
385			{
386			i++;
387			if ( n==1 && i>1 )
388			theNewAlignables.push_back(*ia);
389			else if ( n==2 && i>1 && i<imax )
390			theNewAlignables.push_back(*ia);
391			else if ( n==3 && i>2 && i<imax)
392			theNewAlignables.push_back(*ia);
393			}
394
395			theAlignables = theNewAlignables;
396
397	fpschill	1.3	edm::LogWarning("Alignment") << "removing " << n
398			<< " alignables, so that " << theAlignables.size() << " alignables left";
399	fronga	1.1
400			}
401