Builds a scenario from configuration and applies it to the alignable Muon. More...

#include <MuonScenarioBuilder.h>

Inheritance diagram for MuonScenarioBuilder:

Public Member Functions
void	applyScenario (const edm::ParameterSet &scenario)
	Apply misalignment scenario to the Muon. More...

align::Scalars	extractParameters (const edm::ParameterSet &, const char *)

void	moveChamberInSector (Alignable *, const align::Scalars &, const align::Scalars &, const align::Scalars &, const align::Scalars &)

void	moveCSCSectors (const edm::ParameterSet &scenario)
	this special method allows to move a CSCsector by a same amount More...

void	moveDTSectors (const edm::ParameterSet &scenario)
	This special method allows to move a DTsector by a same amount. More...

void	moveMuon (const edm::ParameterSet &scenario)
	this special method allows to move the complete muon system by a same amount More...

	MuonScenarioBuilder (Alignable *alignable)
	Constructor. More...

	~MuonScenarioBuilder ()
	Destructor. More...

Public Member Functions inherited from MisalignmentScenarioBuilder
	MisalignmentScenarioBuilder (AlignableObjectId::Geometry)
	Constructor. More...

virtual	~MisalignmentScenarioBuilder ()=default
	Destructor. More...

Private Attributes
AlignableMuon *	theAlignableMuon
	Pointer to alignable Muon object. More...

AlignableModifier	theMuonModifier

Additional Inherited Members
Protected Member Functions inherited from MisalignmentScenarioBuilder
void	applyMovements_ (Alignable *alignable, const edm::ParameterSet &pSet)
	Apply movements given by parameter set to given alignable. More...

void	decodeMovements_ (const edm::ParameterSet &pSet, const std::vector< Alignable * > &alignables)
	Decode movements defined in given parameter set for given set of alignables. More...

void	decodeMovements_ (const edm::ParameterSet &pSet, const std::vector< Alignable * > &alignables, const std::string &levelName)
	Decode movements defined in given parameter set for given set of alignables tagged by given name. More...

edm::ParameterSet	getParameterSet_ (const std::string &name, const edm::ParameterSet &pSet) const

edm::ParameterSet	getParameterSet_ (const std::string &levelName, int iComponent, const edm::ParameterSet &pSet) const

bool	hasParameter_ (const std::string &name, const edm::ParameterSet &pSet) const
	Check if given parameter exists in parameter set. More...

virtual bool	isTopLevel_ (const std::string &parameterSetName) const
	Check if given parameter is for a top-level structure. More...

void	mergeParameters_ (edm::ParameterSet &localSet, const edm::ParameterSet &globalSet) const
	Merge two sets of parameters into one (the first argument) More...

virtual bool	possiblyPartOf (const std::string &subStruct, const std::string &largeStruct) const

void	printParameters_ (const edm::ParameterSet &pSet, const bool showPsets=false) const
	Print all parameters and values for given set. More...

void	propagateParameters_ (const edm::ParameterSet &pSet, const std::string &globalName, edm::ParameterSet &subSet) const
	Propagate global parameters to sub-parameters. More...

const std::string	rootName_ (const std::string &parameterSetName) const
	Get root name of a parameter set (e.g. 'Rod' in 'Rods' or 'Rod1') More...

Protected Attributes inherited from MisalignmentScenarioBuilder
std::string	indent_
	Depth in hierarchy. More...

AlignableModifier	theModifier
	Helper class for random movements. More...

int	theModifierCounter {0}
	Counter for applied modification. More...

edm::ParameterSet	theScenario
	Misalignment scenario to apply (from config file) More...

Detailed Description

Builds a scenario from configuration and applies it to the alignable Muon.

The misalignment scenario builder.

Date:: 2009/09/15 17:09:58

Revision:: 1.5

Author: Andre Sznajder - UERJ(Brazil)

Definition at line 21 of file MuonScenarioBuilder.h.

Constructor & Destructor Documentation

MuonScenarioBuilder::MuonScenarioBuilder ( Alignable * alignable )

explicit

Constructor.

Definition at line 25 of file MuonScenarioBuilder.cc.

References Exception, and theAlignableMuon.

                                                                :
   // muon alignable IDs are (currently) independent of the geometry
   MisalignmentScenarioBuilder(AlignableObjectId::Geometry::General)
 {
 
   theAlignableMuon = dynamic_cast<AlignableMuon*>( alignable );
 
   if ( !theAlignableMuon )
     throw cms::Exception("TypeMismatch") << "Argument is not an AlignableMuon";
 
 }

MuonScenarioBuilder::~MuonScenarioBuilder ( )

inline

Destructor.

Definition at line 30 of file MuonScenarioBuilder.h.

30 {};

Member Function Documentation

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

virtual

Apply misalignment scenario to the Muon.

Implements MisalignmentScenarioBuilder.

Definition at line 39 of file MuonScenarioBuilder.cc.

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

Referenced by MuonGeometryDBConverter::analyze(), PCLTrackerAlProducer::applyMisalignment(), AlignmentProducer::beginOfJob(), and MisalignedMuonESProducer::produce().

 {
   // Apply the scenario to all main components of Muon.
   theScenario = scenario;
   theModifierCounter = 0;
 
   // Seed is set at top-level, and is mandatory
   if ( this->hasParameter_( "seed", theScenario ) )
     theModifier.setSeed( static_cast<long>(theScenario.getParameter<int>("seed")) );
   else
     throw cms::Exception("BadConfig") << "No generator seed defined!";  
 
 
 
   // DT Barrel
   std::vector<Alignable*> dtBarrel = theAlignableMuon->DTBarrel();
   this->decodeMovements_( theScenario, dtBarrel, "DTBarrel" );
   // CSC Endcap
   std::vector<Alignable*> cscEndcaps = theAlignableMuon->CSCEndcaps();
   this->decodeMovements_( theScenario, cscEndcaps, "CSCEndcap" );
 
   this->moveDTSectors(theScenario);
   this->moveCSCSectors(theScenario);
   this->moveMuon(theScenario);
   
   edm::LogInfo("TrackerScenarioBuilder") 
     << "Applied modifications to " << theModifierCounter << " alignables";
 }

align::Scalars MuonScenarioBuilder::extractParameters	(	const edm::ParameterSet &	pSet,
		const char *	blockId
	)

Definition at line 70 of file MuonScenarioBuilder.cc.

References relativeConstraints::error, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNames(), MisalignmentScenarioBuilder::getParameterSet_(), edm::ParameterSet::retrieve(), AlCaHLTBitMon_QueryRunRegistry::string, and edm::Entry::typeCode().

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

 {
   double scale_ = 0, scaleError_ = 0, phiX_ = 0, phiY_ = 0, phiZ_ = 0;
   double dX_ = 0, dY_ = 0, dZ_ = 0;
   std::string distribution_;
   std::ostringstream error;
   edm::ParameterSet Parameters = this->getParameterSet_((std::string)blockId, pSet);
   std::vector<std::string> parameterNames = Parameters.getParameterNames();
   for ( std::vector<std::string>::iterator iParam = parameterNames.begin(); iParam != parameterNames.end(); iParam++ ) {
     if ( (*iParam) == "scale" )    scale_ = Parameters.getParameter<double>( *iParam );
     else if ( (*iParam) == "distribution" ) distribution_ = Parameters.getParameter<std::string>( *iParam );
     else if ( (*iParam) == "scaleError" ) scaleError_ = Parameters.getParameter<double>( *iParam );
     else if ( (*iParam) == "phiX" )     phiX_     = Parameters.getParameter<double>( *iParam );
     else if ( (*iParam) == "phiY" )     phiY_     = Parameters.getParameter<double>( *iParam );
     else if ( (*iParam) == "phiZ" )     phiZ_     = Parameters.getParameter<double>( *iParam );
     else if ( (*iParam) == "dX" )       dX_       = Parameters.getParameter<double>( *iParam );
     else if ( (*iParam) == "dY" )       dY_       = Parameters.getParameter<double>( *iParam );
     else if ( (*iParam) == "dZ" )       dZ_       = Parameters.getParameter<double>( *iParam );
     else if ( Parameters.retrieve( *iParam ).typeCode() != 'P' )
       { // Add unknown parameter to list
     if ( !error.str().length() ) error << "Unknown parameter name(s): ";
     error << " " << *iParam;
       }
   }
   align::Scalars param;
   param.push_back(scale_); param.push_back(scaleError_);
   param.push_back(phiX_); param.push_back(phiY_);
   param.push_back(phiZ_); param.push_back(dX_);
   param.push_back(dY_); param.push_back(dZ_);
   if( distribution_ == "gaussian" )
     param.push_back(0);
   else if ( distribution_ == "flat" )
     param.push_back(1);
   else if ( distribution_ == "fix" )
     param.push_back(2);
   
   return param;
 }

void MuonScenarioBuilder::moveChamberInSector	(	Alignable *	chamber,
		const align::Scalars &	_disp,
		const align::Scalars &	rotation,
		const align::Scalars &	dispError,
		const align::Scalars &	rotationError
	)

Definition at line 303 of file MuonScenarioBuilder.cc.

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

Referenced by moveCSCSectors(), and moveDTSectors().

 {
     align::Scalars disp = _disp;
     align::RotationType rotx( Basic3DVector<double>(1.0, 0.0, 0.0), rotation[0] );
     align::RotationType roty( Basic3DVector<double>(0.0, 1.0, 0.0), rotation[1] );
     align::RotationType rotz( Basic3DVector<double>(0.0, 0.0, 1.0), rotation[2] );
     align::RotationType rot = rotz * roty * rotx;
     align::GlobalPoint pos = chamber->globalPosition();
     align::GlobalPoint dispRot(pos.basicVector()-rot*pos.basicVector());
     disp[0] += dispRot.x(); disp[1] += dispRot.y(); disp[2] += dispRot.z();
     theMuonModifier.moveAlignable( chamber, false, true, disp[0], disp[1], disp[2] );
     theMuonModifier.rotateAlignable( chamber, false, true, rotation[0],  rotation[1], rotation[2] );
     theMuonModifier.addAlignmentPositionError( chamber, dispError[0], dispError[1], dispError[2] );
     theMuonModifier.addAlignmentPositionErrorFromRotation( chamber,  rotationError[0], rotationError[1], rotationError[2] );
 }

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

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

Definition at line 172 of file MuonScenarioBuilder.cc.

References counter, AlignableMuon::CSCChambers(), Reference_intrackfit_cff::endcap, extractParameters(), AlignableModifier::flatRandomVector(), AlignableModifier::gaussianRandomVector(), cmsHarvester::index, moveChamberInSector(), relativeConstraints::ring, idealTransformation::rotation, CSCTriggerNumbering::sectorFromTriggerLabels(), relativeConstraints::station, theAlignableMuon, theMuonModifier, CSCTriggerNumbering::triggerSectorFromLabels(), and CSCTriggerNumbering::triggerSubSectorFromLabels().

Referenced by applyScenario().

 {
   std::vector<Alignable *> CSCchambers = theAlignableMuon->CSCChambers();
   //Take Parameters
   align::Scalars param = this->extractParameters(pSet, "CSCSectors");
   double scale_ = param[0]; double scaleError_ = param[1];
   double phiX_ = param[2]; double phiY_ = param[3]; double phiZ_ = param[4];
   double dX_ = param[5]; double dY_ = param[6]; double dZ_ = param[7];
   double dist_ = param[8];
   
   double dx = scale_*dX_; double dy = scale_*dY_; double dz = scale_*dZ_;
   double phix = scale_*phiX_; double phiy = scale_*phiY_; double phiz = scale_*phiZ_;
   double errorx = scaleError_*dX_; double errory = scaleError_*dY_; double errorz = scaleError_*dZ_;
   double errorphix = scaleError_*phiX_; double errorphiy = scaleError_*phiY_; double errorphiz = scaleError_*phiZ_;
   align::Scalars errorDisp;
   errorDisp.push_back(errorx); errorDisp.push_back(errory); errorDisp.push_back(errorz);
   align::Scalars errorRotation;
   errorRotation.push_back(errorphix); errorRotation.push_back(errorphiy); errorRotation.push_back(errorphiz);
   
   int index[2][4][4][36];
   int sector_index[2][4][4][36];
   int counter = 0;
   //Create an index for the chambers in the alignable vector
   for(std::vector<Alignable *>::iterator iter = CSCchambers.begin(); iter != CSCchambers.end(); ++iter) {
     CSCDetId myId((*iter)->geomDetId().rawId());
     index[myId.endcap()-1][myId.station()-1][myId.ring()-1][myId.chamber()-1] = counter;
     sector_index[myId.endcap()-1][myId.station()-1][myId.ring()-1][myId.chamber()-1] = CSCTriggerNumbering::sectorFromTriggerLabels(CSCTriggerNumbering::triggerSectorFromLabels(myId),CSCTriggerNumbering::triggerSubSectorFromLabels(myId) , myId.station());
     counter++;
   }
   for(int endcap = 0; endcap < 2; endcap++) {
     for(int ring = 0; ring < 2; ring++) {
       for(int sector = 1; sector < 7; sector++) {
         align::Scalars disp;
         align::Scalars rotation;
         if( dist_ == 0 ) {
           const std::vector<float> disp_ = theMuonModifier.gaussianRandomVector(dx, dy, dz);
           const std::vector<float> rotation_ = theMuonModifier.gaussianRandomVector(phix, phiy, phiz);
           disp.push_back(disp_[0]); disp.push_back(disp_[1]); disp.push_back(disp_[2]);
           rotation.push_back(rotation_[0]); rotation.push_back(rotation_[1]); rotation.push_back(rotation_[2]);
         } else if (dist_ == 1) {
           const std::vector<float> disp_ = theMuonModifier.flatRandomVector(dx, dy, dz);
           const std::vector<float> rotation_ = theMuonModifier.flatRandomVector(phix, phiy, phiz);
           disp.push_back(disp_[0]); disp.push_back(disp_[1]); disp.push_back(disp_[2]);
           rotation.push_back(rotation_[0]); rotation.push_back(rotation_[1]); rotation.push_back(rotation_[2]);
         } else {
           disp.push_back(dx); disp.push_back(dy); disp.push_back(dz);
           rotation.push_back(phix); rotation.push_back(phiy); rotation.push_back(phiz);
         }
         //Different cases are considered in order to fit endcap geometry
     for(int station = 0; station < 4; station++) {
       if(station == 0) {
         int r_ring[2];
         if(ring == 0) {
           r_ring[0] = 0; r_ring[1] = 3;
         } else {
           r_ring[0] = 1; r_ring[1] = 2;
         }
         for(int r_counter = 0; r_counter < 2; r_counter++) {
           for(int chamber = 0; chamber < 36; chamber++) {
         if(sector == (sector_index[endcap][station][r_ring[r_counter]][chamber]+1)/2) {
           Alignable *myAlign = CSCchambers.at(index[endcap][station][r_ring[r_counter]][chamber]);
                   this->moveChamberInSector(myAlign, disp, rotation, errorDisp, errorRotation);
         }
           }
         }
       } else if(station == 3 && ring == 1) {
         continue;
       } else {
         for(int chamber = 0; chamber < 36; chamber++) {
           if(ring == 0 && chamber > 17) continue;
           if(sector == sector_index[endcap][station][ring][chamber]) {
         Alignable *myAlign = CSCchambers.at(index[endcap][station][ring][chamber]);
                 this->moveChamberInSector(myAlign, disp, rotation, errorDisp, errorRotation);
           }
         }
       }
     }
       }
     }
   }
 }

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

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

Definition at line 110 of file MuonScenarioBuilder.cc.

References counter, AlignableMuon::DTChambers(), extractParameters(), AlignableModifier::flatRandomVector(), AlignableModifier::gaussianRandomVector(), cmsHarvester::index, moveChamberInSector(), idealTransformation::rotation, relativeConstraints::station, theAlignableMuon, and theMuonModifier.

Referenced by applyScenario().

 {
   std::vector<Alignable *> DTchambers = theAlignableMuon->DTChambers();
   //Take parameters
   align::Scalars param = this->extractParameters(pSet, "DTSectors");
   double scale_ = param[0]; double scaleError_ = param[1];
   double phiX_ = param[2]; double phiY_ = param[3]; double phiZ_ = param[4];
   double dX_ = param[5]; double dY_ = param[6]; double dZ_ = param[7];
   double dist_ = param[8];
 
   double dx = scale_*dX_; double dy = scale_*dY_; double dz = scale_*dZ_;
   double phix = scale_*phiX_; double phiy = scale_*phiY_; double phiz = scale_*phiZ_;
   double errorx = scaleError_*dX_; double errory = scaleError_*dY_; double errorz = scaleError_*dZ_;
   double errorphix = scaleError_*phiX_; double errorphiy = scaleError_*phiY_; double errorphiz = scaleError_*phiZ_;
   align::Scalars errorDisp;
   errorDisp.push_back(errorx); errorDisp.push_back(errory); errorDisp.push_back(errorz);
   align::Scalars errorRotation;
   errorRotation.push_back(errorphix); errorRotation.push_back(errorphiy); errorRotation.push_back(errorphiz);
  
   int index[5][4][14];
   int counter = 0;
   //Create and index for the chambers in the Alignable vector
   for(std::vector<Alignable *>::iterator iter = DTchambers.begin(); iter != DTchambers.end(); ++iter) {
     DTChamberId myId((*iter)->geomDetId().rawId());
     index[myId.wheel()+2][myId.station()-1][myId.sector()-1] = counter;
     counter++;
   }
   for(int wheel = 0; wheel < 5; wheel++) {
     for(int sector = 0; sector < 12; sector++) {
       align::Scalars disp;
       align::Scalars rotation;
       if( dist_ == 0 ) {
         const std::vector<float> disp_ = theMuonModifier.gaussianRandomVector(dx, dy, dz);
         const std::vector<float> rotation_ = theMuonModifier.gaussianRandomVector(phix, phiy, phiz);
         disp.push_back(disp_[0]); disp.push_back(disp_[1]); disp.push_back(disp_[2]);
         rotation.push_back(rotation_[0]); rotation.push_back(rotation_[1]); rotation.push_back(rotation_[2]);
       } else if (dist_ == 1) {
         const std::vector<float> disp_ = theMuonModifier.flatRandomVector(dx, dy, dz);
         const std::vector<float> rotation_ = theMuonModifier.flatRandomVector(phix, phiy, phiz);
         disp.push_back(disp_[0]); disp.push_back(disp_[1]); disp.push_back(disp_[2]);
         rotation.push_back(rotation_[0]); rotation.push_back(rotation_[1]); rotation.push_back(rotation_[2]);
       } else {
         disp.push_back(dx); disp.push_back(dy); disp.push_back(dz);
         rotation.push_back(phix); rotation.push_back(phiy); rotation.push_back(phiz);
       }
       for(int station = 0; station < 4; station++) {
         Alignable *myAlign = DTchambers.at(index[wheel][station][sector]);
         this->moveChamberInSector(myAlign, disp, rotation, errorDisp, errorRotation);
         if(sector == 3 && station == 3) {
       Alignable *myAlignD = DTchambers.at(index[wheel][station][12]);
           this->moveChamberInSector(myAlignD, disp, rotation, errorDisp, errorRotation);
     } else if(sector == 9 && station == 3) {
       Alignable *myAlignD = DTchambers.at(index[wheel][station][13]);
           this->moveChamberInSector(myAlignD, disp, rotation, errorDisp, errorRotation);
         }
       }
     }
   } 
 }

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

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

Definition at line 256 of file MuonScenarioBuilder.cc.

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

Referenced by applyScenario().

 {
   std::vector<Alignable *> DTbarrel = theAlignableMuon->DTBarrel(); 
   std::vector<Alignable *> CSCendcaps = theAlignableMuon->CSCEndcaps();  
   //Take Parameters
   align::Scalars param = this->extractParameters(pSet, "Muon");
   double scale_ = param[0]; double scaleError_ = param[1];
   double phiX_ = param[2]; double phiY_ = param[3]; double phiZ_ = param[4];
   double dX_ = param[5]; double dY_ = param[6]; double dZ_ = param[7];
   double dist_ = param[8]; 
   double dx = scale_*dX_; double dy = scale_*dY_; double dz = scale_*dZ_;
   double phix = scale_*phiX_; double phiy = scale_*phiY_; double phiz = scale_*phiZ_;
   double errorx = scaleError_*dX_; double errory = scaleError_*dY_; double errorz = scaleError_*dZ_;
   double errorphix = scaleError_*phiX_; double errorphiy = scaleError_*phiY_; double errorphiz = scaleError_*phiZ_;
   //Create an index for the chambers in the alignable vector
   align::Scalars disp;
   align::Scalars rotation;
   if( dist_ == 0 ) {
     const std::vector<float> disp_ = theMuonModifier.gaussianRandomVector(dx, dy, dz);
     const std::vector<float> rotation_ = theMuonModifier.gaussianRandomVector(phix, phiy, phiz);
     disp.push_back(disp_[0]); disp.push_back(disp_[1]); disp.push_back(disp_[2]);
     rotation.push_back(rotation_[0]); rotation.push_back(rotation_[1]); rotation.push_back(rotation_[2]);
   } else if (dist_ == 1) {
     const std::vector<float> disp_ = theMuonModifier.flatRandomVector(dx, dy, dz);
     const std::vector<float> rotation_ = theMuonModifier.flatRandomVector(phix, phiy, phiz);
     disp.push_back(disp_[0]); disp.push_back(disp_[1]); disp.push_back(disp_[2]);
     rotation.push_back(rotation_[0]); rotation.push_back(rotation_[1]); rotation.push_back(rotation_[2]);
   } else {
     disp.push_back(dx); disp.push_back(dy); disp.push_back(dz);
     rotation.push_back(phix); rotation.push_back(phiy); rotation.push_back(phiz);
   }
   for(std::vector<Alignable *>::iterator iter = DTbarrel.begin(); iter != DTbarrel.end(); ++iter) {
     theMuonModifier.moveAlignable( *iter, false, true, disp[0], disp[1], disp[2] );
     theMuonModifier.rotateAlignable( *iter, false, true, rotation[0],  rotation[1], rotation[2] );
     theMuonModifier.addAlignmentPositionError( *iter, errorx, errory, errorz );
     theMuonModifier.addAlignmentPositionErrorFromRotation( *iter,  errorphix, errorphiy, errorphiz ); 
   }
   for(std::vector<Alignable *>::iterator iter = CSCendcaps.begin(); iter != CSCendcaps.end(); ++iter) {
     theMuonModifier.moveAlignable( *iter, false, true, disp[0], disp[1], disp[2] );
     theMuonModifier.rotateAlignable( *iter, false, true, rotation[0],  rotation[1], rotation[2] );
     theMuonModifier.addAlignmentPositionError( *iter, errorx, errory, errorz );
     theMuonModifier.addAlignmentPositionErrorFromRotation( *iter,  errorphix, errorphiy, errorphiz ); 
   }
 }

Member Data Documentation

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().

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation