CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
MuonScenarioBuilder.cc
Go to the documentation of this file.
1 
9 #include <string>
10 #include <iostream>
11 #include <sstream>
12 
13 // Framework
14 #include "FWCore/Utilities/interface/Exception.h"
15 #include "FWCore/MessageLogger/interface/MessageLogger.h"
16 
17 // Alignment
18 
19 #include "Alignment/MuonAlignment/interface/MuonScenarioBuilder.h"
20 #include "FWCore/ParameterSet/interface/ParameterSet.h"
21 #include "Alignment/CommonAlignment/interface/Alignable.h"
22 #include "DataFormats/MuonDetId/interface/CSCTriggerNumbering.h"
23 
24 //__________________________________________________________________________________________________
25 MuonScenarioBuilder::MuonScenarioBuilder( Alignable* alignable )
26 {
27 
28  theAlignableMuon = dynamic_cast<AlignableMuon*>( alignable );
29 
30  if ( !theAlignableMuon )
31  throw cms::Exception("TypeMismatch") << "Argument is not an AlignableMuon";
32 
33 }
34 
35 
36 //__________________________________________________________________________________________________
37 void MuonScenarioBuilder::applyScenario( const edm::ParameterSet& scenario )
38 {
39  // Apply the scenario to all main components of Muon.
40  theScenario = scenario;
41  theModifierCounter = 0;
42 
43  // Seed is set at top-level, and is mandatory
44  if ( this->hasParameter_( "seed", theScenario ) )
45  theModifier.setSeed( static_cast<long>(theScenario.getParameter<int>("seed")) );
46  else
47  throw cms::Exception("BadConfig") << "No generator seed defined!";
48 
49 
50 
51  // DT Barrel
52  std::vector<Alignable*> dtBarrel = theAlignableMuon->DTBarrel();
53  this->decodeMovements_( theScenario, dtBarrel, "DTBarrel" );
54  // CSC Endcap
55  std::vector<Alignable*> cscEndcaps = theAlignableMuon->CSCEndcaps();
56  this->decodeMovements_( theScenario, cscEndcaps, "CSCEndcap" );
57 
58  this->moveDTSectors(theScenario);
59  this->moveCSCSectors(theScenario);
60  this->moveMuon(theScenario);
61 
62  edm::LogInfo("TrackerScenarioBuilder")
63  << "Applied modifications to " << theModifierCounter << " alignables";
64 }
65 
66 
67 
68 align::Scalars MuonScenarioBuilder::extractParameters(const edm::ParameterSet& pSet, const char *blockId)
69 {
70  double scale_ = 0, scaleError_ = 0, phiX_ = 0, phiY_ = 0, phiZ_ = 0;
71  double dX_ = 0, dY_ = 0, dZ_ = 0;
72  std::string distribution_;
73  std::ostringstream error;
74  edm::ParameterSet Parameters = this->getParameterSet_((std::string)blockId, pSet);
75  std::vector<std::string> parameterNames = Parameters.getParameterNames();
76  for ( std::vector<std::string>::iterator iParam = parameterNames.begin(); iParam != parameterNames.end(); iParam++ ) {
77  if ( (*iParam) == "scale" ) scale_ = Parameters.getParameter<double>( *iParam );
78  else if ( (*iParam) == "distribution" ) distribution_ = Parameters.getParameter<std::string>( *iParam );
79  else if ( (*iParam) == "scaleError" ) scaleError_ = Parameters.getParameter<double>( *iParam );
80  else if ( (*iParam) == "phiX" ) phiX_ = Parameters.getParameter<double>( *iParam );
81  else if ( (*iParam) == "phiY" ) phiY_ = Parameters.getParameter<double>( *iParam );
82  else if ( (*iParam) == "phiZ" ) phiZ_ = Parameters.getParameter<double>( *iParam );
83  else if ( (*iParam) == "dX" ) dX_ = Parameters.getParameter<double>( *iParam );
84  else if ( (*iParam) == "dY" ) dY_ = Parameters.getParameter<double>( *iParam );
85  else if ( (*iParam) == "dZ" ) dZ_ = Parameters.getParameter<double>( *iParam );
86  else if ( Parameters.retrieve( *iParam ).typeCode() != 'P' )
87  { // Add unknown parameter to list
88  if ( !error.str().length() ) error << "Unknown parameter name(s): ";
89  error << " " << *iParam;
90  }
91  }
92  align::Scalars param;
93  param.push_back(scale_); param.push_back(scaleError_);
94  param.push_back(phiX_); param.push_back(phiY_);
95  param.push_back(phiZ_); param.push_back(dX_);
96  param.push_back(dY_); param.push_back(dZ_);
97  if( distribution_ == "gaussian" )
98  param.push_back(0);
99  else if ( distribution_ == "flat" )
100  param.push_back(1);
101  else if ( distribution_ == "fix" )
102  param.push_back(2);
103 
104  return param;
105 }
106 
107 //_____________________________________________________________________________________________________
108 void MuonScenarioBuilder::moveDTSectors(const edm::ParameterSet& pSet)
109 {
110  std::vector<Alignable *> DTchambers = theAlignableMuon->DTChambers();
111  //Take parameters
112  align::Scalars param = this->extractParameters(pSet, "DTSectors");
113  double scale_ = param[0]; double scaleError_ = param[1];
114  double phiX_ = param[2]; double phiY_ = param[3]; double phiZ_ = param[4];
115  double dX_ = param[5]; double dY_ = param[6]; double dZ_ = param[7];
116  double dist_ = param[8];
117 
118  double dx = scale_*dX_; double dy = scale_*dY_; double dz = scale_*dZ_;
119  double phix = scale_*phiX_; double phiy = scale_*phiY_; double phiz = scale_*phiZ_;
120  double errorx = scaleError_*dX_; double errory = scaleError_*dY_; double errorz = scaleError_*dZ_;
121  double errorphix = scaleError_*phiX_; double errorphiy = scaleError_*phiY_; double errorphiz = scaleError_*phiZ_;
122  align::Scalars errorDisp;
123  errorDisp.push_back(errorx); errorDisp.push_back(errory); errorDisp.push_back(errorz);
124  align::Scalars errorRotation;
125  errorRotation.push_back(errorphix); errorRotation.push_back(errorphiy); errorRotation.push_back(errorphiz);
126 
127  int index[5][4][14];
128  int counter = 0;
129  //Create and index for the chambers in the Alignable vector
130  for(std::vector<Alignable *>::iterator iter = DTchambers.begin(); iter != DTchambers.end(); ++iter) {
131  DTChamberId myId((*iter)->geomDetId().rawId());
132  index[myId.wheel()+2][myId.station()-1][myId.sector()-1] = counter;
133  counter++;
134  }
135  for(int wheel = 0; wheel < 5; wheel++) {
136  for(int sector = 0; sector < 12; sector++) {
137  align::Scalars disp;
138  align::Scalars rotation;
139  if( dist_ == 0 ) {
140  const std::vector<float> disp_ = theMuonModifier.gaussianRandomVector(dx, dy, dz);
141  const std::vector<float> rotation_ = theMuonModifier.gaussianRandomVector(phix, phiy, phiz);
142  disp.push_back(disp_[0]); disp.push_back(disp_[1]); disp.push_back(disp_[2]);
143  rotation.push_back(rotation_[0]); rotation.push_back(rotation_[1]); rotation.push_back(rotation_[2]);
144  } else if (dist_ == 1) {
145  const std::vector<float> disp_ = theMuonModifier.flatRandomVector(dx, dy, dz);
146  const std::vector<float> rotation_ = theMuonModifier.flatRandomVector(phix, phiy, phiz);
147  disp.push_back(disp_[0]); disp.push_back(disp_[1]); disp.push_back(disp_[2]);
148  rotation.push_back(rotation_[0]); rotation.push_back(rotation_[1]); rotation.push_back(rotation_[2]);
149  } else {
150  disp.push_back(dx); disp.push_back(dy); disp.push_back(dz);
151  rotation.push_back(phix); rotation.push_back(phiy); rotation.push_back(phiz);
152  }
153  for(int station = 0; station < 4; station++) {
154  Alignable *myAlign = DTchambers.at(index[wheel][station][sector]);
155  this->moveChamberInSector(myAlign, disp, rotation, errorDisp, errorRotation);
156  if(sector == 3 && station == 3) {
157  Alignable *myAlignD = DTchambers.at(index[wheel][station][12]);
158  this->moveChamberInSector(myAlignD, disp, rotation, errorDisp, errorRotation);
159  } else if(sector == 9 && station == 3) {
160  Alignable *myAlignD = DTchambers.at(index[wheel][station][13]);
161  this->moveChamberInSector(myAlignD, disp, rotation, errorDisp, errorRotation);
162  }
163  }
164  }
165  }
166 }
167 
168 
169 //______________________________________________________________________________________________________
170 void MuonScenarioBuilder::moveCSCSectors(const edm::ParameterSet& pSet)
171 {
172  std::vector<Alignable *> CSCchambers = theAlignableMuon->CSCChambers();
173  //Take Parameters
174  align::Scalars param = this->extractParameters(pSet, "CSCSectors");
175  double scale_ = param[0]; double scaleError_ = param[1];
176  double phiX_ = param[2]; double phiY_ = param[3]; double phiZ_ = param[4];
177  double dX_ = param[5]; double dY_ = param[6]; double dZ_ = param[7];
178  double dist_ = param[8];
179 
180  double dx = scale_*dX_; double dy = scale_*dY_; double dz = scale_*dZ_;
181  double phix = scale_*phiX_; double phiy = scale_*phiY_; double phiz = scale_*phiZ_;
182  double errorx = scaleError_*dX_; double errory = scaleError_*dY_; double errorz = scaleError_*dZ_;
183  double errorphix = scaleError_*phiX_; double errorphiy = scaleError_*phiY_; double errorphiz = scaleError_*phiZ_;
184  align::Scalars errorDisp;
185  errorDisp.push_back(errorx); errorDisp.push_back(errory); errorDisp.push_back(errorz);
186  align::Scalars errorRotation;
187  errorRotation.push_back(errorphix); errorRotation.push_back(errorphiy); errorRotation.push_back(errorphiz);
188 
189  int index[2][4][4][36];
190  int sector_index[2][4][4][36];
191  int counter = 0;
192  //Create an index for the chambers in the alignable vector
193  for(std::vector<Alignable *>::iterator iter = CSCchambers.begin(); iter != CSCchambers.end(); ++iter) {
194  CSCDetId myId((*iter)->geomDetId().rawId());
195  index[myId.endcap()-1][myId.station()-1][myId.ring()-1][myId.chamber()-1] = counter;
196  sector_index[myId.endcap()-1][myId.station()-1][myId.ring()-1][myId.chamber()-1] = CSCTriggerNumbering::sectorFromTriggerLabels(CSCTriggerNumbering::triggerSectorFromLabels(myId),CSCTriggerNumbering::triggerSubSectorFromLabels(myId) , myId.station());
197  counter++;
198  }
199  for(int endcap = 0; endcap < 2; endcap++) {
200  for(int ring = 0; ring < 2; ring++) {
201  for(int sector = 1; sector < 7; sector++) {
202  align::Scalars disp;
203  align::Scalars rotation;
204  if( dist_ == 0 ) {
205  const std::vector<float> disp_ = theMuonModifier.gaussianRandomVector(dx, dy, dz);
206  const std::vector<float> rotation_ = theMuonModifier.gaussianRandomVector(phix, phiy, phiz);
207  disp.push_back(disp_[0]); disp.push_back(disp_[1]); disp.push_back(disp_[2]);
208  rotation.push_back(rotation_[0]); rotation.push_back(rotation_[1]); rotation.push_back(rotation_[2]);
209  } else if (dist_ == 1) {
210  const std::vector<float> disp_ = theMuonModifier.flatRandomVector(dx, dy, dz);
211  const std::vector<float> rotation_ = theMuonModifier.flatRandomVector(phix, phiy, phiz);
212  disp.push_back(disp_[0]); disp.push_back(disp_[1]); disp.push_back(disp_[2]);
213  rotation.push_back(rotation_[0]); rotation.push_back(rotation_[1]); rotation.push_back(rotation_[2]);
214  } else {
215  disp.push_back(dx); disp.push_back(dy); disp.push_back(dz);
216  rotation.push_back(phix); rotation.push_back(phiy); rotation.push_back(phiz);
217  }
218  //Different cases are considered in order to fit endcap geometry
219  for(int station = 0; station < 4; station++) {
220  if(station == 0) {
221  int r_ring[2];
222  if(ring == 0) {
223  r_ring[0] = 0; r_ring[1] = 3;
224  } else {
225  r_ring[0] = 1; r_ring[1] = 2;
226  }
227  for(int r_counter = 0; r_counter < 2; r_counter++) {
228  for(int chamber = 0; chamber < 36; chamber++) {
229  if(sector == (sector_index[endcap][station][r_ring[r_counter]][chamber]+1)/2) {
230  Alignable *myAlign = CSCchambers.at(index[endcap][station][r_ring[r_counter]][chamber]);
231  this->moveChamberInSector(myAlign, disp, rotation, errorDisp, errorRotation);
232  }
233  }
234  }
235  } else if(station == 3 && ring == 1) {
236  continue;
237  } else {
238  for(int chamber = 0; chamber < 36; chamber++) {
239  if(ring == 0 && chamber > 17) continue;
240  if(sector == sector_index[endcap][station][ring][chamber]) {
241  Alignable *myAlign = CSCchambers.at(index[endcap][station][ring][chamber]);
242  this->moveChamberInSector(myAlign, disp, rotation, errorDisp, errorRotation);
243  }
244  }
245  }
246  }
247  }
248  }
249  }
250 }
251 
252 
253 //______________________________________________________________________________________________________
254 void MuonScenarioBuilder::moveMuon(const edm::ParameterSet& pSet)
255 {
256  std::vector<Alignable *> DTbarrel = theAlignableMuon->DTBarrel();
257  std::vector<Alignable *> CSCendcaps = theAlignableMuon->CSCEndcaps();
258  //Take Parameters
259  align::Scalars param = this->extractParameters(pSet, "Muon");
260  double scale_ = param[0]; double scaleError_ = param[1];
261  double phiX_ = param[2]; double phiY_ = param[3]; double phiZ_ = param[4];
262  double dX_ = param[5]; double dY_ = param[6]; double dZ_ = param[7];
263  double dist_ = param[8];
264  double dx = scale_*dX_; double dy = scale_*dY_; double dz = scale_*dZ_;
265  double phix = scale_*phiX_; double phiy = scale_*phiY_; double phiz = scale_*phiZ_;
266  double errorx = scaleError_*dX_; double errory = scaleError_*dY_; double errorz = scaleError_*dZ_;
267  double errorphix = scaleError_*phiX_; double errorphiy = scaleError_*phiY_; double errorphiz = scaleError_*phiZ_;
268  //Create an index for the chambers in the alignable vector
269  align::Scalars disp;
270  align::Scalars rotation;
271  if( dist_ == 0 ) {
272  const std::vector<float> disp_ = theMuonModifier.gaussianRandomVector(dx, dy, dz);
273  const std::vector<float> rotation_ = theMuonModifier.gaussianRandomVector(phix, phiy, phiz);
274  disp.push_back(disp_[0]); disp.push_back(disp_[1]); disp.push_back(disp_[2]);
275  rotation.push_back(rotation_[0]); rotation.push_back(rotation_[1]); rotation.push_back(rotation_[2]);
276  } else if (dist_ == 1) {
277  const std::vector<float> disp_ = theMuonModifier.flatRandomVector(dx, dy, dz);
278  const std::vector<float> rotation_ = theMuonModifier.flatRandomVector(phix, phiy, phiz);
279  disp.push_back(disp_[0]); disp.push_back(disp_[1]); disp.push_back(disp_[2]);
280  rotation.push_back(rotation_[0]); rotation.push_back(rotation_[1]); rotation.push_back(rotation_[2]);
281  } else {
282  disp.push_back(dx); disp.push_back(dy); disp.push_back(dz);
283  rotation.push_back(phix); rotation.push_back(phiy); rotation.push_back(phiz);
284  }
285  for(std::vector<Alignable *>::iterator iter = DTbarrel.begin(); iter != DTbarrel.end(); ++iter) {
286  theMuonModifier.moveAlignable( *iter, false, true, disp[0], disp[1], disp[2] );
287  theMuonModifier.rotateAlignable( *iter, false, true, rotation[0], rotation[1], rotation[2] );
288  theMuonModifier.addAlignmentPositionError( *iter, errorx, errory, errorz );
289  theMuonModifier.addAlignmentPositionErrorFromRotation( *iter, errorphix, errorphiy, errorphiz );
290  }
291  for(std::vector<Alignable *>::iterator iter = CSCendcaps.begin(); iter != CSCendcaps.end(); ++iter) {
292  theMuonModifier.moveAlignable( *iter, false, true, disp[0], disp[1], disp[2] );
293  theMuonModifier.rotateAlignable( *iter, false, true, rotation[0], rotation[1], rotation[2] );
294  theMuonModifier.addAlignmentPositionError( *iter, errorx, errory, errorz );
295  theMuonModifier.addAlignmentPositionErrorFromRotation( *iter, errorphix, errorphiy, errorphiz );
296  }
297 }
298 
299 
300 //______________________________________________________________________________________________________
301 void MuonScenarioBuilder::moveChamberInSector(Alignable *chamber, align::Scalars disp, align::Scalars rotation, align::Scalars dispError, align::Scalars rotationError)
302 {
303  align::RotationType rotx( Basic3DVector<double>(1.0, 0.0, 0.0), rotation[0] );
304  align::RotationType roty( Basic3DVector<double>(0.0, 1.0, 0.0), rotation[1] );
305  align::RotationType rotz( Basic3DVector<double>(0.0, 0.0, 1.0), rotation[2] );
306  align::RotationType rot = rotz * roty * rotx;
307  align::GlobalPoint pos = chamber->globalPosition();
308  align::GlobalPoint dispRot(pos.basicVector()-rot*pos.basicVector());
309  disp[0] += dispRot.x(); disp[1] += dispRot.y(); disp[2] += dispRot.z();
310  theMuonModifier.moveAlignable( chamber, false, true, disp[0], disp[1], disp[2] );
311  theMuonModifier.rotateAlignable( chamber, false, true, rotation[0], rotation[1], rotation[2] );
312  theMuonModifier.addAlignmentPositionError( chamber, dispError[0], dispError[1], dispError[2] );
313  theMuonModifier.addAlignmentPositionErrorFromRotation( chamber, rotationError[0], rotationError[1], rotationError[2] );
314 }
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
edm::ParameterSet::retrieve
Entry const & retrieve(char const *) const
Definition: ParameterSet.cc:239
MisalignmentScenarioBuilder::theScenario
edm::ParameterSet theScenario
Misalignment scenario to apply (from config file)
Definition: MisalignmentScenarioBuilder.h:85
MuonScenarioBuilder::theMuonModifier
AlignableModifier theMuonModifier
Definition: MuonScenarioBuilder.h:51
AlignableModifier::setSeed
void setSeed(long seed)
Resets the generator seed according to the argument.
Definition: AlignableModifier.cc:260
AlignableMuon::CSCChambers
align::Alignables CSCChambers()
Definition: AlignableMuon.cc:353
MuonScenarioBuilder::moveCSCSectors
void moveCSCSectors(const edm::ParameterSet &scenario)
this special method allows to move a CSCsector by a same amount
Definition: MuonScenarioBuilder.cc:170
Reference_intrackfit_cff.endcap
endcap
Definition: Reference_intrackfit_cff.py:82
AlignableModifier::addAlignmentPositionError
void addAlignmentPositionError(Alignable *alignable, float dx, float dy, float dz)
Add the AlignmentPositionError (in global frame) to Alignable.
Definition: AlignableModifier.cc:545
MuonScenarioBuilder::theAlignableMuon
AlignableMuon * theAlignableMuon
Pointer to alignable Muon object.
Definition: MuonScenarioBuilder.h:49
AlignableMuon::DTBarrel
align::Alignables DTBarrel()
Definition: AlignableMuon.cc:329
AlignableModifier::gaussianRandomVector
const std::vector< float > gaussianRandomVector(float sigmaX, float sigmaY, float sigmaZ) const
Return a vector of random numbers (gaussian distribution)
Definition: AlignableModifier.cc:461
MuonScenarioBuilder::moveChamberInSector
void moveChamberInSector(Alignable *, align::Scalars, align::Scalars, align::Scalars, align::Scalars)
Definition: MuonScenarioBuilder.cc:301
MuonScenarioBuilder::moveMuon
void moveMuon(const edm::ParameterSet &scenario)
this special method allows to move the complete muon system by a same amount
Definition: MuonScenarioBuilder.cc:254
AlignableModifier::moveAlignable
void moveAlignable(Alignable *alignable, bool random, bool gaussian, float sigmaX, float sigmaY, float sigmaZ)
Move alignable in global space according to parameters.
Definition: AlignableModifier.cc:280
MuonScenarioBuilder::extractParameters
align::Scalars extractParameters(const edm::ParameterSet &, const char *)
Definition: MuonScenarioBuilder.cc:68
AlignableMuon::CSCEndcaps
align::Alignables CSCEndcaps()
Definition: AlignableMuon.cc:377
Parameters
vector< ParameterSet > Parameters
Definition: HLTMuonPlotter.cc:34
CSCTriggerNumbering::sectorFromTriggerLabels
static int sectorFromTriggerLabels(int TriggerSector, int TriggerSubSector, int station)
Definition: CSCTriggerNumbering.cc:68
AlignableMuon::DTChambers
align::Alignables DTChambers()
Definition: AlignableMuon.cc:304
align::Scalars
std::vector< Scalar > Scalars
Definition: Utilities.h:22
MuonScenarioBuilder::MuonScenarioBuilder
MuonScenarioBuilder(Alignable *alignable)
Constructor.
Definition: MuonScenarioBuilder.cc:25
edm::ParameterSet::getParameterNames
std::vector< std::string > getParameterNames() const
Definition: ParameterSet.cc:732
AlignableModifier::flatRandomVector
const std::vector< float > flatRandomVector(float sigmaX, float sigmaY, float sigmaZ) const
Return a vector of random numbers (flat distribution)
Definition: AlignableModifier.cc:495
MisalignmentScenarioBuilder::decodeMovements_
void decodeMovements_(const edm::ParameterSet &pSet, const std::vector< Alignable * > &alignables)
Decode movements defined in given parameter set for given set of alignables.
Definition: MisalignmentScenarioBuilder.cc:24
MuonScenarioBuilder::moveDTSectors
void moveDTSectors(const edm::ParameterSet &scenario)
This special method allows to move a DTsector by a same amount.
Definition: MuonScenarioBuilder.cc:108
AlignableModifier::rotateAlignable
void rotateAlignable(Alignable *alignable, bool random, bool gaussian, float sigmaPhiX, float sigmaPhiY, float sigmaPhiZ)
Rotate alignable in global space according to parameters.
Definition: AlignableModifier.cc:384
MisalignmentScenarioBuilder::theModifier
AlignableModifier theModifier
Helper class for random movements.
Definition: MisalignmentScenarioBuilder.h:86
CSCTriggerNumbering::triggerSectorFromLabels
static int triggerSectorFromLabels(int station, int ring, int chamber)
Definition: CSCTriggerNumbering.cc:83
AlignableModifier::addAlignmentPositionErrorFromRotation
void addAlignmentPositionErrorFromRotation(Alignable *alignable, float phiX, float phiY, float phiZ)
Add alignment position error resulting from rotation in global frame.
Definition: AlignableModifier.cc:585
CSCTriggerNumbering::triggerSubSectorFromLabels
static int triggerSubSectorFromLabels(int station, int chamber)
Definition: CSCTriggerNumbering.cc:118
edm::Entry::typeCode
char typeCode() const
Definition: Entry.h:175
Alignable::globalPosition
const PositionType & globalPosition() const
Return the global position of the object.
Definition: Alignable.h:129
MisalignmentScenarioBuilder::theModifierCounter
int theModifierCounter
Counter for applied modification.
Definition: MisalignmentScenarioBuilder.h:90
AlignableMuon
Constructor of the full muon geometry.
Definition: AlignableMuon.h:36
PV3DBase::x
T x() const
Definition: PV3DBase.h:61
MisalignmentScenarioBuilder::hasParameter_
bool hasParameter_(const std::string &name, const edm::ParameterSet &pSet) const
Check if given parameter exists in parameter set.
Definition: MisalignmentScenarioBuilder.cc:290
PV3DBase::basicVector
const BasicVectorType & basicVector() const
Definition: PV3DBase.h:56
MuonScenarioBuilder::applyScenario
void applyScenario(const edm::ParameterSet &scenario)
Apply misalignment scenario to the Muon.
Definition: MuonScenarioBuilder.cc:37
MisalignmentScenarioBuilder::getParameterSet_
edm::ParameterSet getParameterSet_(const std::string &name, const edm::ParameterSet &pSet) const
Definition: MisalignmentScenarioBuilder.cc:215
Generated for CMSSW Reference Manual by doxygen 1.8.5