CommonAlignmentAlgorithm/src/AlignmentParameterBuilder.cc

/** \file AlignableParameterBuilder.cc
 *
 *  $Date: 2005/07/26 10:13:49 $
 *  $Revision: 1.1 $
 */

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

}

//__________________________________________________________________________________________________
int AlignmentParameterBuilder::addSelections(const edm::ParameterSet &pset)
{
   const std::vector<std::string> selections = 
     pset.getParameter<std::vector<std::string> >("alignableParamSelector");
   bool allOk = true;

   int addedSets = 0;
   for (std::vector<std::string>::const_iterator itSel = selections.begin();
        itSel != selections.end(); ++itSel) {
     std::vector<std::string> decompSel(this->decompose(*itSel, ','));
     if (decompSel.size() < 2) {
       edm::LogError("Alignment") << "@SUB=AlignmentParameterBuilder::addSelections"
                                  << "ignoring " << *itSel << "from alignableParamSelector: "
                                  << "should have at least 2 ','-separated parts";
       allOk = false;
       continue;
     }

     const std::vector<bool> paramSel(this->decodeParamSel(decompSel[1]));
     if (paramSel.size() != RigidBodyAlignmentParameters::N_PARAM) {
       allOk = false; // Error already from decodeParamSel
       continue;
     }
     if (decompSel.size() > 2) {
       edm::LogWarning("Alignment") << "@SUB=AlignmentParameterBuilder::addSelections"
                                    << "r/phi/eta/z-range selection not yet implemented...";
     }
     this->addSelection(decompSel[0], paramSel);
     ++addedSets;
   }

   if (allOk) return addedSets;
   else { // @SUB-syntax is not supported by exception, but anyway useful information...
     throw cms::Exception("BadConfig") <<"@SUB=AlignmentParameterBuilder::addSelections"
                                       << ": Problems decoding 'alignableParamSelector'.";
     return -1;
   }
}

//__________________________________________________________________________________________________
std::vector<bool> AlignmentParameterBuilder::decodeParamSel(const std::string &selString) const
{

  if (selString.length() != RigidBodyAlignmentParameters::N_PARAM) {
    edm::LogError("Alignment") <<"@SUB=AlignmentParameterBuilder::decodeSelections"
                               << "selectionString has wrong size " << selString.length()
                               << " instead of " << RigidBodyAlignmentParameters::N_PARAM;
    return std::vector<bool>();
  } else {
    std::vector<bool> result(RigidBodyAlignmentParameters::N_PARAM, false);
    // shifts
    if (selString.substr(0,1)=="1") result[RigidBodyAlignmentParameters::dx] = true;
    if (selString.substr(1,1)=="1") result[RigidBodyAlignmentParameters::dy] = true;
    if (selString.substr(2,1)=="1") result[RigidBodyAlignmentParameters::dz] = true;
    // rotations
    if (selString.substr(3,1)=="1") result[RigidBodyAlignmentParameters::dalpha] = true;
    if (selString.substr(4,1)=="1") result[RigidBodyAlignmentParameters::dbeta] = true;
    if (selString.substr(5,1)=="1") result[RigidBodyAlignmentParameters::dgamma] = true;

    return result;
  }

}


//__________________________________________________________________________________________________
std::vector<std::string> 
AlignmentParameterBuilder::decompose(const std::string &s, std::string::value_type delimiter) const
{

  std::vector<std::string> result;

  std::string::size_type previousPos = 0;
  while (true) {
    const std::string::size_type delimiterPos = s.find(delimiter, previousPos);
    if (delimiterPos == std::string::npos) {
      result.push_back(s.substr(previousPos)); // until end
      break;
    }
    result.push_back(s.substr(previousPos, delimiterPos - previousPos));
    previousPos = delimiterPos + 1;
  }

  return result;
}

//__________________________________________________________________________________________________
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;
  }
  else if (name == "BarrelSSRods") {
    theOnlySS = true;
    add(theAlignableTracker->barrelRods(), sel);
    theOnlySS = 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 { // @SUB-syntax is not supported by exception, but anyway useful information... 
    throw cms::Exception("BadConfig") <<"@SUB=AlignmentParameterBuilder::addSelection"
                                      << ": Selection '" << name << "' 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.5
Committed:	Fri Oct 20 13:24:55 2006 UTC (18 years, 6 months ago) by flucke
Content type:	text/plain
Branch:	MAIN
CVS Tags:	CMSSW_1_2_0_pre4, V00-05-00, CMSSW_1_2_0_pre3, V00-04-00
Changes since 1.4:	+124 -25 lines
Log Message:	- add new selection BarrelSSRod - enable sequential selection of several sets via an edm::ParameterSet - exception instead of error in case of unknown selection - some indentation (no tabs in code!)
#	User	Rev	Content
1	flucke	1.5	/** \file AlignableParameterBuilder.cc
2			*
3			* $Date: 2005/07/26 10:13:49 $
4			* $Revision: 1.1 $
5			*/
6
7	fronga	1.1	#include "FWCore/MessageLogger/interface/MessageLogger.h"
8			#include "Geometry/CommonDetAlgo/interface/AlgebraicObjects.h"
9			#include "Alignment/CommonAlignment/interface/Alignable.h"
10			#include "Alignment/CommonAlignment/interface/AlignableDet.h"
11			#include "Alignment/CommonAlignment/interface/AlignableComposite.h"
12
13			#include "Alignment/CommonAlignmentParametrization/interface/RigidBodyAlignmentParameters.h"
14			#include "Alignment/CommonAlignmentParametrization/interface/CompositeRigidBodyAlignmentParameters.h"
15
16			// This class's header
17
18			#include "Alignment/CommonAlignmentAlgorithm/interface/AlignmentParameterBuilder.h"
19
20
21			//__________________________________________________________________________________________________
22			AlignmentParameterBuilder::AlignmentParameterBuilder( AlignableTracker* alignableTracker )
23			{
24
25			theAlignableTracker = alignableTracker;
26
27			theTrackerAlignableId = new TrackerAlignableId();
28			theOnlyDS=false;
29			theOnlySS=false;
30			theSelLayers=false;
31			theMinLayer=-1;
32			theMaxLayer=999;
33
34			}
35
36			//__________________________________________________________________________________________________
37	flucke	1.5	int AlignmentParameterBuilder::addSelections(const edm::ParameterSet &pset)
38			{
39			const std::vector<std::string> selections =
40			pset.getParameter<std::vector<std::string> >("alignableParamSelector");
41			bool allOk = true;
42
43			int addedSets = 0;
44			for (std::vector<std::string>::const_iterator itSel = selections.begin();
45			itSel != selections.end(); ++itSel) {
46			std::vector<std::string> decompSel(this->decompose(*itSel, ','));
47			if (decompSel.size() < 2) {
48			edm::LogError("Alignment") << "@SUB=AlignmentParameterBuilder::addSelections"
49			<< "ignoring " << *itSel << "from alignableParamSelector: "
50			<< "should have at least 2 ','-separated parts";
51			allOk = false;
52			continue;
53			}
54
55			const std::vector<bool> paramSel(this->decodeParamSel(decompSel[1]));
56			if (paramSel.size() != RigidBodyAlignmentParameters::N_PARAM) {
57			allOk = false; // Error already from decodeParamSel
58			continue;
59			}
60			if (decompSel.size() > 2) {
61			edm::LogWarning("Alignment") << "@SUB=AlignmentParameterBuilder::addSelections"
62			<< "r/phi/eta/z-range selection not yet implemented...";
63			}
64			this->addSelection(decompSel[0], paramSel);
65			++addedSets;
66			}
67
68			if (allOk) return addedSets;
69			else { // @SUB-syntax is not supported by exception, but anyway useful information...
70			throw cms::Exception("BadConfig") <<"@SUB=AlignmentParameterBuilder::addSelections"
71			<< ": Problems decoding 'alignableParamSelector'.";
72			return -1;
73			}
74			}
75
76			//__________________________________________________________________________________________________
77			std::vector<bool> AlignmentParameterBuilder::decodeParamSel(const std::string &selString) const
78			{
79
80			if (selString.length() != RigidBodyAlignmentParameters::N_PARAM) {
81			edm::LogError("Alignment") <<"@SUB=AlignmentParameterBuilder::decodeSelections"
82			<< "selectionString has wrong size " << selString.length()
83			<< " instead of " << RigidBodyAlignmentParameters::N_PARAM;
84			return std::vector<bool>();
85			} else {
86			std::vector<bool> result(RigidBodyAlignmentParameters::N_PARAM, false);
87			// shifts
88			if (selString.substr(0,1)=="1") result[RigidBodyAlignmentParameters::dx] = true;
89			if (selString.substr(1,1)=="1") result[RigidBodyAlignmentParameters::dy] = true;
90			if (selString.substr(2,1)=="1") result[RigidBodyAlignmentParameters::dz] = true;
91			// rotations
92			if (selString.substr(3,1)=="1") result[RigidBodyAlignmentParameters::dalpha] = true;
93			if (selString.substr(4,1)=="1") result[RigidBodyAlignmentParameters::dbeta] = true;
94			if (selString.substr(5,1)=="1") result[RigidBodyAlignmentParameters::dgamma] = true;
95
96			return result;
97			}
98
99			}
100
101
102			//__________________________________________________________________________________________________
103			std::vector<std::string>
104			AlignmentParameterBuilder::decompose(const std::string &s, std::string::value_type delimiter) const
105			{
106
107			std::vector<std::string> result;
108
109			std::string::size_type previousPos = 0;
110			while (true) {
111			const std::string::size_type delimiterPos = s.find(delimiter, previousPos);
112			if (delimiterPos == std::string::npos) {
113			result.push_back(s.substr(previousPos)); // until end
114			break;
115			}
116			result.push_back(s.substr(previousPos, delimiterPos - previousPos));
117			previousPos = delimiterPos + 1;
118			}
119
120			return result;
121			}
122
123			//__________________________________________________________________________________________________
124	flucke	1.4	void AlignmentParameterBuilder::addSelection(const std::string &name, const std::vector<bool> &sel)
125	fronga	1.1	{
126
127	fpschill	1.3	edm::LogWarning("Alignment") << "[AlignmentParameterBuilder] Called for selection >" << name<<"<";
128	fronga	1.1
129			if (name == "AllDets") addAllDets(sel);
130			else if (name == "AllRods") addAllRods(sel);
131			else if (name == "AllLayers") addAllLayers(sel);
132			else if (name == "AllComponents") addAllComponents(sel);
133			else if (name == "AllAlignables") addAllAlignables(sel);
134
135			// TIB+TOB
136			else if (name == "BarrelRods") add(theAlignableTracker->barrelRods(),sel);
137			else if (name == "BarrelDets") add(theAlignableTracker->barrelGeomDets(),sel);
138			else if (name == "BarrelLayers") add(theAlignableTracker->barrelLayers(),sel);
139
140	flucke	1.5	else if (name == "BarrelDSRods") {
141			theOnlyDS = true;
142			add(theAlignableTracker->barrelRods(), sel);
143			theOnlyDS = false;
144			}
145			else if (name == "BarrelSSRods") {
146			theOnlySS = true;
147			add(theAlignableTracker->barrelRods(), sel);
148			theOnlySS = false;
149			}
150	fronga	1.1
151			// PXBarrel
152			else if (name == "PixelHalfBarrelDets")
153			add(theAlignableTracker->pixelHalfBarrelGeomDets(),sel);
154			else if (name == "PixelHalfBarrelLadders")
155			add(theAlignableTracker->pixelHalfBarrelLadders(),sel);
156			else if (name == "PixelHalfBarrelLayers")
157			add(theAlignableTracker->pixelHalfBarrelLayers(),sel);
158
159			else if (name == "PixelHalfBarrelLaddersLayers12") {
160			theSelLayers=true; theMinLayer=1; theMaxLayer=2;
161			add(theAlignableTracker->pixelHalfBarrelLadders(),sel);
162			}
163
164
165			// PXEndcap
166			else if (name == "PXECDets") add(theAlignableTracker->pixelEndcapGeomDets(),sel);
167			else if (name == "PXECPetals") add(theAlignableTracker->pixelEndcapPetals(),sel);
168			else if (name == "PXECLayers") add(theAlignableTracker->pixelEndcapLayers(),sel);
169
170			// Pixel Barrel+endcap
171			else if (name == "PixelDets") {
172			add(theAlignableTracker->pixelHalfBarrelGeomDets(),sel);
173			add(theAlignableTracker->pixelEndcapGeomDets(),sel);
174			}
175			else if (name == "PixelRods") {
176			add(theAlignableTracker->pixelHalfBarrelLadders(),sel);
177			add(theAlignableTracker->pixelEndcapPetals(),sel);
178			}
179			else if (name == "PixelLayers") {
180			add(theAlignableTracker->pixelHalfBarrelLayers(),sel);
181			add(theAlignableTracker->pixelEndcapLayers(),sel);
182			}
183
184			// TID
185			else if (name == "TIDLayers") add(theAlignableTracker->TIDLayers(),sel);
186			else if (name == "TIDRings") add(theAlignableTracker->TIDRings(),sel);
187			else if (name == "TIDDets") add(theAlignableTracker->TIDGeomDets(),sel);
188
189			// TEC
190			else if (name == "TECDets") add(theAlignableTracker->endcapGeomDets(),sel);
191			else if (name == "TECPetals") add(theAlignableTracker->endcapPetals(),sel);
192			else if (name == "TECLayers") add(theAlignableTracker->endcapLayers(),sel);
193
194			// StripEndcap (TID+TEC)
195			else if (name == "EndcapDets") {
196			add(theAlignableTracker->TIDGeomDets(),sel);
197			add(theAlignableTracker->endcapGeomDets(),sel);
198			}
199			else if (name == "EndcapPetals") {
200			add(theAlignableTracker->TIDRings(),sel);
201			add(theAlignableTracker->endcapPetals(),sel);
202			}
203			else if (name == "EndcapLayers") {
204			add(theAlignableTracker->TIDLayers(),sel);
205			add(theAlignableTracker->endcapLayers(),sel);
206			}
207
208			// Strip Barrel+endcap
209			else if (name == "StripDets") {
210			add(theAlignableTracker->barrelGeomDets(),sel);
211			add(theAlignableTracker->TIDGeomDets(),sel);
212			add(theAlignableTracker->endcapGeomDets(),sel);
213			}
214			else if (name == "StripRods") {
215			add(theAlignableTracker->barrelRods(),sel);
216			add(theAlignableTracker->TIDRings(),sel);
217			add(theAlignableTracker->endcapPetals(),sel);
218			}
219			else if (name == "StripLayers") {
220			add(theAlignableTracker->barrelLayers(),sel);
221			add(theAlignableTracker->TIDLayers(),sel);
222			add(theAlignableTracker->endcapLayers(),sel);
223			}
224
225
226			// Custom scenarios
227
228			else if (name == "ScenarioA") {
229	flucke	1.5	std::vector<bool> mysel(6,false);
230	fronga	1.1	// pixel barrel dets x,y,z
231			mysel[RigidBodyAlignmentParameters::dx]=true;
232			mysel[RigidBodyAlignmentParameters::dy]=true;
233			mysel[RigidBodyAlignmentParameters::dz]=true;
234			add(theAlignableTracker->pixelHalfBarrelGeomDets(),mysel);
235			// strip barrel double sided
236			theOnlyDS = true;
237			add(theAlignableTracker->barrelRods(),mysel);
238			theOnlyDS = false;
239			// strip barrel single sided
240			mysel[RigidBodyAlignmentParameters::dy]=false;
241			theOnlySS = true;
242			add(theAlignableTracker->barrelRods(),mysel);
243			theOnlySS = false;
244			}
245
246			else if (name == "ScenarioB") {
247	flucke	1.5	std::vector<bool> mysel(6,false);
248	fronga	1.1	// pixel barrel ladders x,y,z
249			mysel[RigidBodyAlignmentParameters::dx]=true;
250			mysel[RigidBodyAlignmentParameters::dy]=true;
251			mysel[RigidBodyAlignmentParameters::dz]=true;
252			add(theAlignableTracker->pixelHalfBarrelLadders(),mysel);
253			// strip barrel layers double sided
254			theOnlyDS = true;
255			add(theAlignableTracker->barrelLayers(),mysel);
256			theOnlyDS = false;
257			// strip barrel layers single sided
258			mysel[RigidBodyAlignmentParameters::dy]=false;
259			theOnlySS = true;
260			add(theAlignableTracker->barrelLayers(),mysel);
261			theOnlySS = false;
262			}
263
264
265			else if (name == "CustomStripLayers") {
266	flucke	1.5	std::vector<bool> mysel(6,false);
267	fronga	1.1	mysel[RigidBodyAlignmentParameters::dx]=true;
268			mysel[RigidBodyAlignmentParameters::dy]=true;
269			mysel[RigidBodyAlignmentParameters::dz]=true;
270			// strip barrel layers double sided
271			theOnlyDS = true;
272			add(theAlignableTracker->barrelLayers(),mysel);
273			theOnlyDS = false;
274			// strip barrel layers single sided
275			mysel[RigidBodyAlignmentParameters::dz]=false;
276			theOnlySS = true;
277			add(theAlignableTracker->barrelLayers(),mysel);
278			theOnlySS = false;
279			// TID
280			mysel[RigidBodyAlignmentParameters::dz]=true;
281			add(theAlignableTracker->TIDLayers(),mysel);
282			// TEC
283			mysel[RigidBodyAlignmentParameters::dz]=false;
284			add(theAlignableTracker->endcapLayers(),mysel);
285			}
286
287			else if (name == "CustomStripRods") {
288	flucke	1.5	std::vector<bool> mysel(6,false);
289	fronga	1.1	mysel[RigidBodyAlignmentParameters::dx]=true;
290			mysel[RigidBodyAlignmentParameters::dy]=true;
291			mysel[RigidBodyAlignmentParameters::dz]=true;
292			// strip barrel layers double sided
293			theOnlyDS = true;
294			add(theAlignableTracker->barrelRods(),mysel);
295			theOnlyDS = false;
296			// strip barrel layers single sided
297			mysel[RigidBodyAlignmentParameters::dy]=false;
298			theOnlySS = true;
299			add(theAlignableTracker->barrelRods(),mysel);
300			theOnlySS = false;
301			// TID
302			mysel[RigidBodyAlignmentParameters::dy]=true;
303			add(theAlignableTracker->TIDRings(),mysel);
304			// TEC
305			mysel[RigidBodyAlignmentParameters::dz]=false;
306			add(theAlignableTracker->endcapPetals(),mysel);
307			}
308
309	flucke	1.5	else { // @SUB-syntax is not supported by exception, but anyway useful information...
310			throw cms::Exception("BadConfig") <<"@SUB=AlignmentParameterBuilder::addSelection"
311			<< ": Selection '" << name << "' invalid!";
312			}
313	fpschill	1.3	edm::LogInfo("Warning") << "[AlignmentParameterBuilder] Added "
314	flucke	1.5	<< theAlignables.size()<< " alignables in total";
315	fronga	1.1
316			}
317
318
319			//__________________________________________________________________________________________________
320	flucke	1.4	void AlignmentParameterBuilder::addAllDets(const std::vector<bool> &sel)
321	fronga	1.1	{
322
323			add(theAlignableTracker->barrelGeomDets(),sel); // TIB+TOB
324			add(theAlignableTracker->endcapGeomDets(),sel); // TEC
325			add(theAlignableTracker->TIDGeomDets(),sel); // TID
326			add(theAlignableTracker->pixelHalfBarrelGeomDets(),sel); // PixelBarrel
327			add(theAlignableTracker->pixelEndcapGeomDets(),sel); // PixelEndcap
328
329	fpschill	1.3	edm::LogInfo("Alignment") << "Initialized for "
330	flucke	1.5	<< theAlignables.size() << " dets";
331	fronga	1.1	}
332
333
334			//__________________________________________________________________________________________________
335	flucke	1.4	void AlignmentParameterBuilder::addAllRods(const std::vector<bool> &sel)
336	fronga	1.1	{
337			add(theAlignableTracker->barrelRods(),sel);
338			add(theAlignableTracker->pixelHalfBarrelLadders(),sel);
339			add(theAlignableTracker->endcapPetals(),sel);
340			add(theAlignableTracker->TIDRings(),sel);
341			add(theAlignableTracker->pixelEndcapPetals(),sel);
342
343	fpschill	1.3	edm::LogInfo("Alignment") << "Initialized for "
344	flucke	1.5	<< theAlignables.size() << " rods";
345	fronga	1.1	}
346
347
348			//__________________________________________________________________________________________________
349	flucke	1.4	void AlignmentParameterBuilder::addAllLayers(const std::vector<bool> &sel)
350	fronga	1.1	{
351			add(theAlignableTracker->barrelLayers(),sel);
352			add(theAlignableTracker->pixelHalfBarrelLayers(),sel);
353			add(theAlignableTracker->endcapLayers(),sel);
354			add(theAlignableTracker->TIDLayers(),sel);
355			add(theAlignableTracker->pixelEndcapLayers(),sel);
356
357	fpschill	1.3	edm::LogInfo("Alignment") << "Initialized for "
358	flucke	1.5	<< theAlignables.size() << " layers";
359	fronga	1.1
360			}
361
362
363			//__________________________________________________________________________________________________
364	flucke	1.4	void AlignmentParameterBuilder::addAllComponents(const std::vector<bool> &sel)
365	fronga	1.1	{
366			add(theAlignableTracker->components(),sel);
367	fpschill	1.3	edm::LogInfo("Alignment") << "Initialized for "
368	flucke	1.5	<< theAlignables.size()
369			<< " Components (HalfBarrel/Endcap)";
370	fronga	1.1	}
371
372
373			//__________________________________________________________________________________________________
374	flucke	1.4	void AlignmentParameterBuilder::addAllAlignables(const std::vector<bool> &sel)
375	fronga	1.1	{
376
377			add(theAlignableTracker->barrelGeomDets(),sel);
378			add(theAlignableTracker->endcapGeomDets(),sel);
379			add(theAlignableTracker->TIDGeomDets(),sel);
380			add(theAlignableTracker->pixelHalfBarrelGeomDets(),sel);
381			add(theAlignableTracker->pixelEndcapGeomDets(),sel);
382
383			add(theAlignableTracker->barrelRods(),sel);
384			add(theAlignableTracker->pixelHalfBarrelLadders(),sel);
385			add(theAlignableTracker->endcapPetals(),sel);
386			add(theAlignableTracker->TIDRings(),sel);
387			add(theAlignableTracker->pixelEndcapPetals(),sel);
388
389			add(theAlignableTracker->barrelLayers(),sel);
390			add(theAlignableTracker->pixelHalfBarrelLayers(),sel);
391			add(theAlignableTracker->endcapLayers(),sel);
392			add(theAlignableTracker->TIDLayers(),sel);
393			add(theAlignableTracker->pixelEndcapLayers(),sel);
394
395			add(theAlignableTracker->components(),sel);
396
397
398	fpschill	1.3	edm::LogInfo("Alignment") << "Initialized for "
399	flucke	1.5	<< theAlignables.size()
400			<< " Components (HalfBarrel/Endcap)";
401	fronga	1.1
402			}
403
404
405			//__________________________________________________________________________________________________
406	flucke	1.4	void AlignmentParameterBuilder::add(const std::vector<Alignable*> &alignables,
407			const std::vector<bool> &sel)
408	fronga	1.1	{
409
410			int num_adu = 0;
411			int num_det = 0;
412			int num_hlo = 0;
413
414			// loop on Alignable objects
415			for ( std::vector<Alignable*>::const_iterator ia=alignables.begin();
416			ia!=alignables.end(); ia++ ) {
417			Alignable* ali=(*ia);
418
419			// select on single/double sided barrel layers
420			std::pair<int,int> tl=theTrackerAlignableId->typeAndLayerFromAlignable( ali );
421			int type = tl.first;
422			int layer = tl.second;
423
424			bool keep=true;
425			if (theOnlySS) // only single sided
426			if ( (abs(type)==3 \|\| abs(type)==5) && layer<2 )
427			keep=false;
428
429			if (theOnlyDS) // only double sided
430			if ( (abs(type)==3 \|\| abs(type)==5) && layer>1 )
431			keep=false;
432
433			// reject layers
434			if ( theSelLayers && (layer<theMinLayer \|\| layer>theMaxLayer) )
435			keep=false;
436
437
438			if (keep) {
439
440			AlgebraicVector par(6,0);
441			AlgebraicSymMatrix cov(6,0);
442
443			AlignableDet* alidet = dynamic_cast<AlignableDet*>(ali);
444			if (alidet !=0) { // alignable Det
445			RigidBodyAlignmentParameters* dap =
446			new RigidBodyAlignmentParameters(ali,par,cov,sel);
447	flucke	1.4	ali->setAlignmentParameters(dap);
448	fronga	1.1	num_det++;
449	flucke	1.4	} else { // higher level object
450	fronga	1.1	CompositeRigidBodyAlignmentParameters* dap =
451			new CompositeRigidBodyAlignmentParameters(ali,par,cov,sel);
452			ali->setAlignmentParameters(dap);
453			num_hlo++;
454			}
455
456			theAlignables.push_back(ali);
457			num_adu++;
458
459			}
460			}
461
462	fpschill	1.3	edm::LogWarning("Alignment") << "Added " << num_adu
463	flucke	1.5	<< " Alignables, of which " << num_det << " are Dets and "
464			<< num_hlo << " are higher level.";
465	fronga	1.1
466			}
467
468
469			//__________________________________________________________________________________________________
470			void AlignmentParameterBuilder::fixAlignables(int n)
471			{
472
473	fpschill	1.3	if (n<1 \|\| n>3) {
474	flucke	1.5	edm::LogError("BadArgument") << " n = " << n << " is not in [1,3]";
475	fronga	1.1	return;
476			}
477
478			std::vector<Alignable*> theNewAlignables;
479			int i=0;
480			int imax = theAlignables.size();
481			for ( std::vector<Alignable*>::const_iterator ia=theAlignables.begin();
482			ia!=theAlignables.end(); ia++ )
483			{
484			i++;
485			if ( n==1 && i>1 )
486			theNewAlignables.push_back(*ia);
487			else if ( n==2 && i>1 && i<imax )
488			theNewAlignables.push_back(*ia);
489			else if ( n==3 && i>2 && i<imax)
490			theNewAlignables.push_back(*ia);
491			}
492
493			theAlignables = theNewAlignables;
494
495	fpschill	1.3	edm::LogWarning("Alignment") << "removing " << n
496	flucke	1.5	<< " alignables, so that " << theAlignables.size()
497			<< " alignables left";
498	fronga	1.1
499			}
500