CMSSW Reference Manual

MuonScenarioBuilder::MuonScenarioBuilder ( Alignable * alignable ) [explicit]

Constructor.

Definition at line 25 of file MuonScenarioBuilder.cc.

References Exception, and theAlignableMuon.

00026 {
00027 
00028   theAlignableMuon = dynamic_cast<AlignableMuon*>( alignable );
00029 
00030   if ( !theAlignableMuon )
00031     throw cms::Exception("TypeMismatch") << "Argument is not an AlignableMuon";
00032 
00033 }

MuonScenarioBuilder::~MuonScenarioBuilder ( ) [inline]

Destructor.

Definition at line 30 of file MuonScenarioBuilder.h.

00030 {};

void MuonScenarioBuilder::applyScenario ( const edm::ParameterSet & scenario ) [virtual]

Apply misalignment scenario to the Muon.

Implements MisalignmentScenarioBuilder.

Definition at line 37 of file MuonScenarioBuilder.cc.

References AlignableMuon::CSCEndcaps(), MisalignmentScenarioBuilder::decodeMovements_(), AlignableMuon::DTBarrel(), Exception, edm::ParameterSet::getParameter(), moveCSCSectors(), moveDTSectors(), moveMuon(), AlignableModifier::setSeed(), theAlignableMuon, MisalignmentScenarioBuilder::theModifier, MisalignmentScenarioBuilder::theModifierCounter, and MisalignmentScenarioBuilder::theScenario.

Referenced by MuonGeometryIntoNtuples::beginJob(), AlignmentProducer::beginOfJob(), and MisalignedMuonESProducer::produce().

00038 {
00039 
00040   // Apply the scenario to all main components of Muon.
00041   theScenario = scenario;
00042   theModifierCounter = 0;
00043 
00044   // Seed is set at top-level, and is mandatory
00045   if ( this->hasParameter_( "seed", theScenario ) )
00046         theModifier.setSeed( static_cast<long>(theScenario.getParameter<int>("seed")) );
00047   else
00048         throw cms::Exception("BadConfig") << "No generator seed defined!";  
00049 
00050 
00051 
00052   // DT Barrel
00053   std::vector<Alignable*> dtBarrel = theAlignableMuon->DTBarrel();
00054   this->decodeMovements_( theScenario, dtBarrel, "DTBarrel" );
00055   // CSC Endcap
00056   std::vector<Alignable*> cscEndcaps = theAlignableMuon->CSCEndcaps();
00057   this->decodeMovements_( theScenario, cscEndcaps, "CSCEndcap" );
00058 
00059   this->moveDTSectors(theScenario);
00060   this->moveCSCSectors(theScenario);
00061   this->moveMuon(theScenario);
00062   
00063   edm::LogInfo("TrackerScenarioBuilder") 
00064         << "Applied modifications to " << theModifierCounter << " alignables";
00065 
00066 }

std::vector< float > MuonScenarioBuilder::extractParameters	(	const edm::ParameterSet &	pSet,
		char *	blockId
	)

Definition at line 70 of file MuonScenarioBuilder.cc.

References error, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNames(), MisalignmentScenarioBuilder::getParameterSet_(), and edm::ParameterSet::retrieve().

Referenced by moveCSCSectors(), moveDTSectors(), and moveMuon().

00070                                                                                                   {
00071   
00072   double scale_ = 0, scaleError_ = 0, phiX_ = 0, phiY_ = 0, phiZ_ = 0;
00073   double dX_ = 0, dY_ = 0, dZ_ = 0;
00074   
00075   std::ostringstream error;
00076   edm::ParameterSet Parameters = this->getParameterSet_((std::string)blockId, pSet);
00077   std::vector<std::string> parameterNames = Parameters.getParameterNames();
00078   for ( std::vector<std::string>::iterator iParam = parameterNames.begin(); iParam != parameterNames.end(); iParam++ ) {
00079     if ( (*iParam) == "scale" )    scale_ = Parameters.getParameter<double>( *iParam );
00080     else if ( (*iParam) == "scaleError" ) scaleError_ = Parameters.getParameter<double>( *iParam );
00081     else if ( (*iParam) == "phiX" )     phiX_     = Parameters.getParameter<double>( *iParam );
00082     else if ( (*iParam) == "phiY" )     phiY_     = Parameters.getParameter<double>( *iParam );
00083     else if ( (*iParam) == "phiZ" )     phiZ_     = Parameters.getParameter<double>( *iParam );
00084     else if ( (*iParam) == "dX" )       dX_       = Parameters.getParameter<double>( *iParam );
00085     else if ( (*iParam) == "dY" )       dY_       = Parameters.getParameter<double>( *iParam );
00086     else if ( (*iParam) == "dZ" )       dZ_       = Parameters.getParameter<double>( *iParam );
00087     else if ( Parameters.retrieve( *iParam ).typeCode() != 'P' )
00088       { // Add unknown parameter to list
00089         if ( !error.str().length() ) error << "Unknown parameter name(s): ";
00090         error << " " << *iParam;
00091       }
00092   }
00093   std::vector<float> param;
00094   param.push_back(scale_); param.push_back(scaleError_);
00095   param.push_back(phiX_); param.push_back(phiY_);
00096   param.push_back(phiZ_); param.push_back(dX_);
00097   param.push_back(dY_); param.push_back(dZ_);
00098   return param;
00099 
00100 }

void MuonScenarioBuilder::moveChamberInSector	(	Alignable *	chamber,
		std::vector< float >	disp,
		std::vector< float >	rotation,
		std::vector< float >	dispError,
		std::vector< float >	rotationError
	)

Definition at line 253 of file MuonScenarioBuilder.cc.

References AlignableModifier::addAlignmentPositionError(), AlignableModifier::addAlignmentPositionErrorFromRotation(), PV3DBase< T, PVType, FrameType >::basicVector(), Alignable::globalPosition(), AlignableModifier::moveAlignable(), rot, AlignableModifier::rotateAlignable(), and theMuonModifier.

Referenced by moveCSCSectors(), and moveDTSectors().

00253                                                                                                                                                                              {
00254    
00255     align::RotationType rotx( Basic3DVector<float>(1.0, 0.0, 0.0), rotation[0] );
00256     align::RotationType roty( Basic3DVector<float>(0.0, 1.0, 0.0), rotation[1] );
00257     align::RotationType rotz( Basic3DVector<float>(0.0, 0.0, 1.0), rotation[2] );
00258     align::RotationType rot = rotz * roty * rotx;
00259     GlobalPoint pos = chamber->globalPosition();
00260     GlobalPoint dispRot(pos.basicVector()-rot*pos.basicVector());
00261     disp[0] += dispRot.x(); disp[1] += dispRot.y(); disp[2] += dispRot.z();
00262     theMuonModifier.moveAlignable( chamber, false, true, disp[0], disp[1], disp[2] );
00263     theMuonModifier.rotateAlignable( chamber, false, true, rotation[0],  rotation[1], rotation[2] );
00264     theMuonModifier.addAlignmentPositionError( chamber, dispError[0], dispError[1], dispError[2] );
00265     theMuonModifier.addAlignmentPositionErrorFromRotation( chamber,  rotationError[0], rotationError[1], rotationError[2] );
00266 
00267 }

void MuonScenarioBuilder::moveCSCSectors ( const edm::ParameterSet & scenario )

this special method allows to move a CSCsector by a same amount

Definition at line 151 of file MuonScenarioBuilder.cc.

References counter(), AlignableMuon::CSCChambers(), GeomDetEnumerators::endcap, extractParameters(), AlignableModifier::gaussianRandomVector(), index, iter, moveChamberInSector(), CSCTriggerNumbering::sectorFromTriggerLabels(), theAlignableMuon, theMuonModifier, CSCTriggerNumbering::triggerSectorFromLabels(), and CSCTriggerNumbering::triggerSubSectorFromLabels().

Referenced by applyScenario().

00151                                                                     {
00152   
00153   std::vector<Alignable *> CSCchambers = theAlignableMuon->CSCChambers();
00154   //Take Parameters
00155   std::vector<float> param = this->extractParameters(pSet, "CSCsectors");
00156   float scale_ = param[0]; float scaleError_ = param[1];
00157   float phiX_ = param[2]; float phiY_ = param[3]; float phiZ_ = param[4];
00158   float dX_ = param[5]; float dY_ = param[6]; float dZ_ = param[7];
00159   
00160   float dx = scale_*dX_; float dy = scale_*dY_; float dz = scale_*dZ_;
00161   float phix = scale_*phiX_; float phiy = scale_*phiY_; float phiz = scale_*phiZ_;
00162   float errorx = scaleError_*dX_; float errory = scaleError_*dY_; float errorz = scaleError_*dZ_;
00163   float errorphix = scaleError_*phiX_; float errorphiy = scaleError_*phiY_; float errorphiz = scaleError_*phiZ_;
00164   std::vector<float> errorDisp;
00165   errorDisp.push_back(errorx); errorDisp.push_back(errory); errorDisp.push_back(errorz);
00166   std::vector<float> errorRotation;
00167   errorRotation.push_back(errorphix); errorRotation.push_back(errorphiy); errorRotation.push_back(errorphiz);
00168   
00169   int index[2][4][4][36];
00170   int sector_index[2][4][4][36];
00171   int counter = 0;
00172   //Create an index for the chambers in the alignable vector
00173   for(std::vector<Alignable *>::iterator iter = CSCchambers.begin(); iter != CSCchambers.end(); ++iter) {
00174     CSCDetId myId((*iter)->geomDetId().rawId());
00175     index[myId.endcap()-1][myId.station()-1][myId.ring()-1][myId.chamber()-1] = counter;
00176     sector_index[myId.endcap()-1][myId.station()-1][myId.ring()-1][myId.chamber()-1] = CSCTriggerNumbering::sectorFromTriggerLabels(CSCTriggerNumbering::triggerSectorFromLabels(myId),CSCTriggerNumbering::triggerSubSectorFromLabels(myId) , myId.station());
00177     counter++;
00178   }
00179   for(int endcap = 0; endcap < 2; endcap++) {
00180     for(int ring = 0; ring < 2; ring++) {
00181       for(int sector = 1; sector < 7; sector++) {
00182         const std::vector<float> disp = theMuonModifier.gaussianRandomVector(dx, dy, dz);
00183         const std::vector<float> rotation = theMuonModifier.gaussianRandomVector(phix, phiy, phiz);
00184         //Different cases are considered in order to fit endcap geometry
00185         for(int station = 0; station < 4; station++) {
00186           if(station == 0) {
00187             int r_ring[2];
00188             if(ring == 0) {
00189               r_ring[0] = 0; r_ring[1] = 3;
00190             } else {
00191               r_ring[0] = 1; r_ring[1] = 2;
00192             }
00193             for(int r_counter = 0; r_counter < 2; r_counter++) {
00194               for(int chamber = 0; chamber < 36; chamber++) {
00195                 if(sector == (sector_index[endcap][station][r_ring[r_counter]][chamber]+1)/2) {
00196                   Alignable *myAlign = CSCchambers.at(index[endcap][station][r_ring[r_counter]][chamber]);
00197                   this->moveChamberInSector(myAlign, disp, rotation, errorDisp, errorRotation);
00198                 }
00199               }
00200             }
00201           } else if(station == 3 && ring == 1) {
00202             continue;
00203           } else {
00204             for(int chamber = 0; chamber < 36; chamber++) {
00205               if(ring == 0 && chamber > 17) continue;
00206               if(sector == sector_index[endcap][station][ring][chamber]) {
00207                 Alignable *myAlign = CSCchambers.at(index[endcap][station][ring][chamber]);
00208                 this->moveChamberInSector(myAlign, disp, rotation, errorDisp, errorRotation);
00209               }
00210             }
00211           }
00212         }
00213       }
00214     }
00215   }
00216 }

void MuonScenarioBuilder::moveDTSectors ( const edm::ParameterSet & scenario )

This special method allows to move a DTsector by a same amount.

Definition at line 103 of file MuonScenarioBuilder.cc.

References counter(), AlignableMuon::DTChambers(), extractParameters(), AlignableModifier::gaussianRandomVector(), index, iter, moveChamberInSector(), theAlignableMuon, theMuonModifier, and muonGeometry::wheel.

Referenced by applyScenario().

00103                                                                    {
00104   
00105   std::vector<Alignable *> DTchambers = theAlignableMuon->DTChambers();
00106   //Take parameters
00107   std::vector<float> param = this->extractParameters(pSet, "DTsectors");
00108   float scale_ = param[0]; float scaleError_ = param[1];
00109   float phiX_ = param[2]; float phiY_ = param[3]; float phiZ_ = param[4];
00110   float dX_ = param[5]; float dY_ = param[6]; float dZ_ = param[7];
00111   
00112   float dx = scale_*dX_; float dy = scale_*dY_; float dz = scale_*dZ_;
00113   float phix = scale_*phiX_; float phiy = scale_*phiY_; float phiz = scale_*phiZ_;
00114   float errorx = scaleError_*dX_; float errory = scaleError_*dY_; float errorz = scaleError_*dZ_;
00115   float errorphix = scaleError_*phiX_; float errorphiy = scaleError_*phiY_; float errorphiz = scaleError_*phiZ_;
00116   std::vector<float> errorDisp;
00117   errorDisp.push_back(errorx); errorDisp.push_back(errory); errorDisp.push_back(errorz);
00118   std::vector<float> errorRotation;
00119   errorRotation.push_back(errorphix); errorRotation.push_back(errorphiy); errorRotation.push_back(errorphiz);
00120  
00121   int index[5][4][14];
00122   int counter = 0;
00123   //Create and index for the chambers in the Alignable vector
00124   for(std::vector<Alignable *>::iterator iter = DTchambers.begin(); iter != DTchambers.end(); ++iter) {
00125     DTChamberId myId((*iter)->geomDetId().rawId());
00126     index[myId.wheel()+2][myId.station()-1][myId.sector()-1] = counter;
00127     counter++;
00128   }
00129   for(int wheel = 0; wheel < 5; wheel++) {
00130     for(int sector = 0; sector < 12; sector++) {
00131       const std::vector<float> disp = theMuonModifier.gaussianRandomVector(dx, dy, dz);
00132       const std::vector<float> rotation = theMuonModifier.gaussianRandomVector(phix, phiy, phiz);
00133       for(int station = 0; station < 4; station++) {
00134         Alignable *myAlign = DTchambers.at(index[wheel][station][sector]);
00135         this->moveChamberInSector(myAlign, disp, rotation, errorDisp, errorRotation);
00136         if(sector == 3 && station == 3) {
00137           Alignable *myAlignD = DTchambers.at(index[wheel][station][12]);
00138           this->moveChamberInSector(myAlignD, disp, rotation, errorDisp, errorRotation);
00139         } else if(sector == 9 && station == 3) {
00140           Alignable *myAlignD = DTchambers.at(index[wheel][station][13]);
00141           this->moveChamberInSector(myAlignD, disp, rotation, errorDisp, errorRotation);
00142         }
00143       }
00144     }
00145   } 
00146 }

void MuonScenarioBuilder::moveMuon ( const edm::ParameterSet & scenario )

this special method allows to move the complete muon system by a same amount

Definition at line 220 of file MuonScenarioBuilder.cc.

References AlignableModifier::addAlignmentPositionError(), AlignableModifier::addAlignmentPositionErrorFromRotation(), AlignableMuon::CSCEndcaps(), AlignableMuon::DTBarrel(), extractParameters(), AlignableModifier::gaussianRandomVector(), iter, AlignableModifier::moveAlignable(), AlignableModifier::rotateAlignable(), theAlignableMuon, and theMuonModifier.

Referenced by applyScenario().

00220                                                               {
00221 
00222   std::vector<Alignable *> DTbarrel = theAlignableMuon->DTBarrel();     
00223   std::vector<Alignable *> CSCendcaps = theAlignableMuon->CSCEndcaps();  
00224   //Take Parameters
00225   std::vector<float> param = this->extractParameters(pSet, "Muons");
00226   float scale_ = param[0]; float scaleError_ = param[1];
00227   float phiX_ = param[2]; float phiY_ = param[3]; float phiZ_ = param[4];
00228   float dX_ = param[5]; float dY_ = param[6]; float dZ_ = param[7];
00229   float dx = scale_*dX_; float dy = scale_*dY_; float dz = scale_*dZ_;
00230   float phix = scale_*phiX_; float phiy = scale_*phiY_; float phiz = scale_*phiZ_;
00231   float errorx = scaleError_*dX_; float errory = scaleError_*dY_; float errorz = scaleError_*dZ_;
00232   float errorphix = scaleError_*phiX_; float errorphiy = scaleError_*phiY_; float errorphiz = scaleError_*phiZ_;
00233   //Create an index for the chambers in the alignable vector
00234   const std::vector<float> disp = theMuonModifier.gaussianRandomVector(dx, dy, dz);
00235   const std::vector<float> rotation = theMuonModifier.gaussianRandomVector(phix, phiy, phiz);
00236   for(std::vector<Alignable *>::iterator iter = DTbarrel.begin(); iter != DTbarrel.end(); ++iter) {
00237     theMuonModifier.moveAlignable( *iter, false, true, disp[0], disp[1], disp[2] );
00238     theMuonModifier.rotateAlignable( *iter, false, true, rotation[0],  rotation[1], rotation[2] );
00239     theMuonModifier.addAlignmentPositionError( *iter, errorx, errory, errorz );
00240     theMuonModifier.addAlignmentPositionErrorFromRotation( *iter,  errorphix, errorphiy, errorphiz ); 
00241   }
00242   for(std::vector<Alignable *>::iterator iter = CSCendcaps.begin(); iter != CSCendcaps.end(); ++iter) {
00243     theMuonModifier.moveAlignable( *iter, false, true, disp[0], disp[1], disp[2] );
00244     theMuonModifier.rotateAlignable( *iter, false, true, rotation[0],  rotation[1], rotation[2] );
00245     theMuonModifier.addAlignmentPositionError( *iter, errorx, errory, errorz );
00246     theMuonModifier.addAlignmentPositionErrorFromRotation( *iter,  errorphix, errorphiy, errorphiz ); 
00247   }
00248   
00249 }

AlignableMuon* MuonScenarioBuilder::theAlignableMuon [private]

Pointer to alignable Muon object.

Definition at line 49 of file MuonScenarioBuilder.h.

Referenced by applyScenario(), moveCSCSectors(), moveDTSectors(), moveMuon(), and MuonScenarioBuilder().

AlignableModifier MuonScenarioBuilder::theMuonModifier [private]

Definition at line 51 of file MuonScenarioBuilder.h.

Referenced by moveChamberInSector(), moveCSCSectors(), moveDTSectors(), and moveMuon().

MuonScenarioBuilder Class Reference

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation


Public Member Functions
void	applyScenario (const edm::ParameterSet &scenario)
	Apply misalignment scenario to the Muon.
std::vector< float >	extractParameters (const edm::ParameterSet &, char *)
void	moveChamberInSector (Alignable *, std::vector< float >, std::vector< float >, std::vector< float >, std::vector< float >)
void	moveCSCSectors (const edm::ParameterSet &scenario)
	this special method allows to move a CSCsector by a same amount
void	moveDTSectors (const edm::ParameterSet &scenario)
	This special method allows to move a DTsector by a same amount.
void	moveMuon (const edm::ParameterSet &scenario)
	this special method allows to move the complete muon system by a same amount
	MuonScenarioBuilder (Alignable *alignable)
	Constructor.
	~MuonScenarioBuilder ()
	Destructor.
Private Attributes
AlignableMuon *	theAlignableMuon
	Pointer to alignable Muon object.
AlignableModifier	theMuonModifier