Constructor of the full muon geometry. More...

#include <AlignableMuon.h>

Inheritance diagram for AlignableMuon:

Public Member Functions
	AlignableMuon (const DTGeometry , const CSCGeometry , const GEMGeometry *)
	Constructor from geometries. More...

const align::Alignables &	components () const final
	Return all components. More...

AlignmentErrorsExtended *	cscAlignmentErrorsExtended ()
	Get CSC alignment errors sorted by DetId. More...

Alignments *	cscAlignments ()
	Get CSC alignments sorted by DetId. More...

align::Alignables	CSCChambers ()

align::Alignables	CSCEndcaps ()

align::Alignables	CSCLayers ()

align::Alignables	CSCRings ()

align::Alignables	CSCStations ()

AlignmentErrorsExtended *	dtAlignmentErrorsExtended ()
	Get DT alignment errors sorted by DetId. More...

Alignments *	dtAlignments ()
	Get DT alignments sorted by DetId. More...

align::Alignables	DTBarrel ()

align::Alignables	DTChambers ()

align::Alignables	DTLayers ()
	Methods to return specific of components. More...

align::Alignables	DTStations ()

align::Alignables	DTSuperLayers ()

align::Alignables	DTWheels ()

AlignmentErrorsExtended *	gemAlignmentErrorsExtended ()

Alignments *	gemAlignments ()

align::Alignables	GEMChambers ()

align::Alignables	GEMEndcaps ()

align::Alignables	GEMEtaPartitions ()

align::Alignables	GEMRings ()

align::Alignables	GEMStations ()

align::Alignables	GEMSuperChambers ()

virtual Alignable *	mother ()
	Alignable tracker has no mother. More...

const AlignableObjectId &	objectIdProvider () const
	Return muon alignable object ID provider derived from the muon system geometry. More...

void	update (const DTGeometry , const CSCGeometry , const GEMGeometry *)

	~AlignableMuon () override
	Destructor. More...

Public Member Functions inherited from AlignableComposite
void	addAlignmentPositionError (const AlignmentPositionError &ape, bool propagateDown) override

void	addAlignmentPositionErrorFromLocalRotation (const RotationType &rotation, bool propagateDown) override

void	addAlignmentPositionErrorFromRotation (const RotationType &rotation, bool propagateDown) override

void	addComponent (Alignable *component) final

void	addSurfaceDeformation (const SurfaceDeformation *deformation, bool propagateDown) override

	AlignableComposite (align::ID id, StructureType aType, const RotationType &rot=RotationType())

StructureType	alignableObjectId () const override
	Return the alignable type identifier. More...

void	dump () const override
	Recursive printout of alignable structure. More...

void	move (const GlobalVector &displacement) override
	Move with respect to the global reference frame. More...

virtual void	moveComponentLocal (const int i, const LocalVector &localDisplacement)
	Move a single component with respect to the local reference frame. More...

virtual void	moveComponentsLocal (const LocalVector &localDisplacement)
	Move with respect to the local reference frame. More...

void	recursiveComponents (Alignables &result) const override
	Provide all components, subcomponents etc. (cf. description in base class) More...

void	rotateInGlobalFrame (const RotationType &rotation) override
	Rotation interpreted in global reference frame. More...

void	setAlignmentPositionError (const AlignmentPositionError &ape, bool propagateDown) override

void	setSurfaceDeformation (const SurfaceDeformation *deformation, bool propagateDown) override
	Set the surface deformation parameters - if (!propagateDown) do not affect daughters. More...

int	surfaceDeformationIdPairs (std::vector< std::pair< int, SurfaceDeformation * > > &) const override
	Return surface deformations. More...

void	update (align::ID, StructureType aType, const RotationType &rot=RotationType())

template<class T >
void	update (T)=delete

	~AlignableComposite () override
	deleting its components More...

Public Member Functions inherited from Alignable
	Alignable (align::ID, const AlignableSurface &)

	Alignable (align::ID, const RotationType &)

AlignmentParameters *	alignmentParameters () const
	Get the AlignmentParameters. More...

virtual void	cacheTransformation ()
	cache the current position, rotation and other parameters (e.g. surface deformations), also for possible components More...

virtual void	cacheTransformation (const align::RunNumber &)

virtual CompConstraintType	compConstraintType () const
	Return the alignable type of contraints wrt. its components. More...

const Alignables &	deepComponents () const

const GlobalVector &	displacement () const
	Return change of the global position since the creation of the object. More...

bool	firstCompsWithParams (Alignables &paramComps) const

const DetId &	geomDetId () const

const PositionType &	globalPosition () const
	Return the global position of the object. More...

const RotationType &	globalRotation () const
	Return the global orientation of the object. More...

align::ID	id () const
	Return the ID of Alignable, i.e. DetId of 'first' component GeomDet(Unit). More...

bool	lastCompsWithParams (Alignables &paramComps) const

Alignable *	mother () const
	Return pointer to container alignable (if any) More...

virtual void	recenterSurface ()
	Recenter surface object without moving possible components. More...

virtual void	restoreCachedTransformation ()
	restore the previously cached transformation, also for possible components More...

virtual void	restoreCachedTransformation (const align::RunNumber &)

virtual void	rotateAroundGlobalAxis (const GlobalVector &axis, Scalar radians)
	Rotation around arbitratry global axis. More...

virtual void	rotateAroundGlobalX (Scalar radians)
	Rotation around global x-axis. More...

virtual void	rotateAroundGlobalY (Scalar radians)
	Rotation around global y-axis. More...

virtual void	rotateAroundGlobalZ (Scalar radians)
	Rotation around global z-axis. More...

virtual void	rotateAroundLocalAxis (const LocalVector &axis, Scalar radians)
	Rotation around arbitratry local axis. More...

virtual void	rotateAroundLocalX (Scalar radians)
	Rotation around local x-axis. More...

virtual void	rotateAroundLocalY (Scalar radians)
	Rotation around local y-axis. More...

virtual void	rotateAroundLocalZ (Scalar radians)
	Rotation around local z-axis. More...

virtual void	rotateInLocalFrame (const RotationType &rotation)
	Rotation intepreted in the local reference frame. More...

const RotationType &	rotation () const
	Return change of orientation since the creation of the object. More...

void	setAlignmentParameters (AlignmentParameters *dap)
	Set the AlignmentParameters. More...

void	setMother (Alignable *mother)
	Assign mother to alignable. More...

void	setSurvey (const SurveyDet *)
	Set survey info. More...

int	size () const
	Return number of direct components. More...

const AlignableSurface &	surface () const
	Return the Surface (global position and orientation) of the object. More...

AlignmentSurfaceDeformations *	surfaceDeformations () const
	Return surface deformations, sorted by DetId. More...

const SurveyDet *	survey () const
	Return survey info. More...

void	update (align::ID, const AlignableSurface &)

virtual	~Alignable ()
	Destructor. More...

Private Member Functions
AlignmentErrorsExtended *	alignmentErrors () const override
	Get alignment errors sorted by DetId. More...

Alignments *	alignments () const override
	Get alignments sorted by DetId. More...

void	buildCSCEndcap (const CSCGeometry *, bool update=false)
	Build muon end caps. More...

void	buildDTBarrel (const DTGeometry *, bool update=false)
	Build muon barrel. More...

void	buildGEMEndcap (const GEMGeometry *, bool update=false)

RotationType	computeOrientation ()
	Get the global orientation (no rotation by default) More...

PositionType	computePosition ()
	Get the position (centered at 0 by default) More...

AlignableSurface	computeSurface ()
	Get the Surface. More...

void	recursiveSetMothers (Alignable *alignable)
	Set mothers recursively. More...

Private Attributes
const AlignableObjectId	alignableObjectId_
	alignable object ID provider More...

std::vector < AlignableCSCChamber * >	theCSCChambers

std::vector< AlignableCSCEndcap * >	theCSCEndcaps

std::vector< AlignableCSCRing * >	theCSCRings

std::vector < AlignableCSCStation * >	theCSCStations

std::vector< AlignableDTBarrel * >	theDTBarrel

std::vector< AlignableDTChamber * >	theDTChambers
	Containers of separate components. More...

std::vector< AlignableDTStation * >	theDTStations

std::vector< AlignableDTWheel * >	theDTWheels

std::vector< AlignableGEMEndcap * >	theGEMEndcaps

std::vector< AlignableGEMRing * >	theGEMRings

std::vector < AlignableGEMStation * >	theGEMStations

std::vector < AlignableGEMSuperChamber * >	theGEMSuperChambers

align::Alignables	theMuonComponents

Additional Inherited Members
Public Types inherited from Alignable
typedef align::Alignables	Alignables

enum	CompConstraintType { CompConstraintType::NONE, CompConstraintType::POSITION, CompConstraintType::POSITION_Z }

typedef align::GlobalVector	GlobalVector

typedef align::LocalVector	LocalVector

typedef align::PositionType	PositionType

typedef align::RotationType	RotationType

typedef align::Scalar	Scalar

typedef align::StructureType	StructureType

Protected Types inherited from Alignable
template<class T >
using	Cache = std::map< align::RunNumber, T >

Protected Member Functions inherited from AlignableComposite
	AlignableComposite (const GeomDet *geomDet)
	Constructor from GeomDet, only for use in AlignableDet. More...

void	setSurface (const AlignableSurface &s)

void	update (const GeomDet *geomDet)

Protected Member Functions inherited from Alignable
void	addDisplacement (const GlobalVector &displacement)

void	addRotation (const RotationType &rotation)

virtual void	updateMother (const GlobalVector &shift)

Protected Attributes inherited from AlignableComposite
StructureType	theStructureType

Protected Attributes inherited from Alignable
Cache< GlobalVector >	displacementsCache_

Cache< RotationType >	rotationsCache_

Cache< AlignableSurface >	surfacesCache_

GlobalVector	theCachedDisplacement

RotationType	theCachedRotation

AlignableSurface	theCachedSurface

Alignables	theDeepComponents

DetId	theDetId

GlobalVector	theDisplacement

align::ID	theId

RotationType	theRotation

AlignableSurface	theSurface

Detailed Description

Constructor of the full muon geometry.

The alignable muon.

Date:: 2008/04/25 21:23:15

Revision:: 1.21

Author: Andre Sznajder - UERJ(Brazil)

Definition at line 38 of file AlignableMuon.h.

Constructor & Destructor Documentation

AlignableMuon::AlignableMuon	(	const DTGeometry *	dtGeometry,
		const CSCGeometry *	cscGeometry,
		const GEMGeometry *	gemGeometry
	)

Constructor from geometries.

Definition at line 36 of file AlignableMuon.cc.

References buildCSCEndcap(), buildDTBarrel(), buildGEMEndcap(), components(), recursiveSetMothers(), and Alignable::theId.

     : AlignableComposite(0, align::AlignableMuon),  // cannot yet set id, use 0
       alignableObjectId_(nullptr, dtGeometry, cscGeometry, gemGeometry) {
   // Build the muon barrel
   buildDTBarrel(dtGeometry);
 
   // Build the muon end caps
   buildCSCEndcap(cscGeometry);
   buildGEMEndcap(gemGeometry);
 
   // Set links to mothers recursively
   recursiveSetMothers(this);
 
   // now can set id as for all composites: id of first component
   theId = this->components()[0]->id();
 
   edm::LogInfo("AlignableMuon") << "Constructing alignable muon objects DONE";
 }

AlignableMuon::~AlignableMuon ( )

override

Destructor.

Definition at line 58 of file AlignableMuon.cc.

References theMuonComponents.

                               {
   for (align::Alignables::iterator iter = theMuonComponents.begin(); iter != theMuonComponents.end(); iter++) {
     delete *iter;
   }
 }

Member Function Documentation

AlignmentErrorsExtended * AlignableMuon::alignmentErrors ( void ) const

overrideprivatevirtual

Get alignment errors sorted by DetId.

Reimplemented from AlignableComposite.

Definition at line 535 of file AlignableMuon.cc.

References AlCaHLTBitMon_QueryRunRegistry::comp, components(), filterCSVwithJSON::copy, mps_fire::i, and AlignmentErrorsExtended::m_alignError.

                                                                   {
   align::Alignables comp = this->components();
   AlignmentErrorsExtended* m_alignmentErrors = new AlignmentErrorsExtended();
 
   // Add components recursively
   for (align::Alignables::iterator i = comp.begin(); i != comp.end(); i++) {
     AlignmentErrorsExtended* tmpAlignmentErrorsExtended = (*i)->alignmentErrors();
     std::copy(tmpAlignmentErrorsExtended->m_alignError.begin(),
               tmpAlignmentErrorsExtended->m_alignError.end(),
               std::back_inserter(m_alignmentErrors->m_alignError));
     delete tmpAlignmentErrorsExtended;
   }
 
   // sort by rawId
   std::sort(m_alignmentErrors->m_alignError.begin(), m_alignmentErrors->m_alignError.end());
 
   return m_alignmentErrors;
 }

Alignments * AlignableMuon::alignments ( void ) const

overrideprivatevirtual

Get alignments sorted by DetId.

Reimplemented from AlignableComposite.

Definition at line 519 of file AlignableMuon.cc.

References AlCaHLTBitMon_QueryRunRegistry::comp, components(), filterCSVwithJSON::copy, mps_fire::i, and Alignments::m_align.

                                                 {
   align::Alignables comp = this->components();
   Alignments* m_alignments = new Alignments();
   // Add components recursively
   for (align::Alignables::iterator i = comp.begin(); i != comp.end(); i++) {
     Alignments* tmpAlignments = (*i)->alignments();
     std::copy(tmpAlignments->m_align.begin(), tmpAlignments->m_align.end(), std::back_inserter(m_alignments->m_align));
     delete tmpAlignments;
   }
 
   // sort by rawId
   std::sort(m_alignments->m_align.begin(), m_alignments->m_align.end());
 
   return m_alignments;
 }

void AlignableMuon::buildCSCEndcap	(	const CSCGeometry *	pCSC,
		bool	update = `false`
	)

private

Build muon end caps.

Definition at line 170 of file AlignableMuon.cc.

References align::AlignableCSCChamber, align::AlignableCSCEndcap, align::AlignableCSCRing, align::AlignableCSCStation, CSCGeometry::chambers(), CSCDetId::endcap(), LogDebug, CSCDetId::ring(), CSCDetId::station(), theCSCChambers, theCSCEndcaps, theCSCRings, theCSCStations, and theMuonComponents.

Referenced by AlignableMuon(), and update().

                                                                        {
   LogDebug("Position") << "Constructing AlignableCSCBarrel";
 
   // Temporary container for stations in a given endcap
   std::vector<AlignableCSCStation*> tmpCSCStationsInEndcap;
 
   // Loop over endcaps ( 1..2 )
   for (int iec = 1; iec < 3; iec++) {
     // Temporary container for rings in a given station
     std::vector<AlignableCSCRing*> tmpCSCRingsInStation;
 
     // Loop over stations ( 1..4 )
     for (int ist = 1; ist < 5; ist++) {
       // Temporary container for chambers in a given ring
       std::vector<AlignableCSCChamber*> tmpCSCChambersInRing;
 
       // Loop over rings ( 1..4 )
       for (int iri = 1; iri < 5; iri++) {
         // Loop over geom CSC Chambers
         int iChamber{0};
         const CSCGeometry::ChamberContainer& vc = pCSC->chambers();
         for (const auto& det : vc) {
           // Get the CSCDet ID
           CSCDetId cscId = det->id();
 
           // Get chamber, station, ring, layer and endcap labels of the CSC chamber
           int ec = cscId.endcap();
           int st = cscId.station();
           int ri = cscId.ring();
           //int ch = cscId.chamber();
 
           // Select the chambers in a given endcap, station, and ring
           if (iec == ec && ist == st && iri == ri) {
             if (update) {
               // Update the alignable CSC chamber
               theCSCEndcaps[iec - 1]->station(ist - 1).ring(iri - 1).chamber(iChamber).update(det);
             } else {
               AlignableCSCChamber* tmpCSCChamber = new AlignableCSCChamber(det);
 
               // Store the alignable CSC chambers
               tmpCSCChambersInRing.push_back(tmpCSCChamber);
             }
 
             ++iChamber;
             // End If chamber selection
           }
 
           // End loop over geom CSC chambers
         }
 
         if (!update) {
           // Not all stations have 4 rings: only add the rings that exist (have chambers associated with them)
           if (!tmpCSCChambersInRing.empty()) {
             // Store the alignable CSC chambers
             theCSCChambers.insert(theCSCChambers.end(), tmpCSCChambersInRing.begin(), tmpCSCChambersInRing.end());
 
             // Create the alignable CSC ring with chambers in a given ring
             AlignableCSCRing* tmpCSCRing = new AlignableCSCRing(tmpCSCChambersInRing);
 
             // Store the CSC rings in a given station
             tmpCSCRingsInStation.push_back(tmpCSCRing);
 
             // Clear the temporary vector of chambers in ring
             tmpCSCChambersInRing.clear();
 
             // End if this ring exists
           }
         }
 
         // End loop over rings
       }
 
       if (!update) {
         // Create the alignable CSC station with rings in a given station
         AlignableCSCStation* tmpCSCStation = new AlignableCSCStation(tmpCSCRingsInStation);
 
         // Store the alignable CSC rings
         theCSCRings.insert(theCSCRings.end(), tmpCSCRingsInStation.begin(), tmpCSCRingsInStation.end());
 
         // Store the CSC stations in a given endcap
         tmpCSCStationsInEndcap.push_back(tmpCSCStation);
 
         // Clear the temporary vector of rings in station
         tmpCSCRingsInStation.clear();
       }
 
       // End loop over stations
     }
 
     if (!update) {
       // Create the alignable CSC endcap
       AlignableCSCEndcap* tmpEndcap = new AlignableCSCEndcap(tmpCSCStationsInEndcap);
 
       // Store the alignable CSC stations
       theCSCStations.insert(theCSCStations.end(), tmpCSCStationsInEndcap.begin(), tmpCSCStationsInEndcap.end());
 
       // Store the alignable CSC endcaps
       theCSCEndcaps.push_back(tmpEndcap);
 
       // Clear the temporary vector of stations in endcap
       tmpCSCStationsInEndcap.clear();
     }
 
     // End loop over endcaps
   }
 
   if (!update) {
     // Store the encaps in the muon components
     theMuonComponents.insert(theMuonComponents.end(), theCSCEndcaps.begin(), theCSCEndcaps.end());
   }
 }

void AlignableMuon::buildDTBarrel	(	const DTGeometry *	pDT,
		bool	update = `false`
	)

private

Build muon barrel.

Definition at line 80 of file AlignableMuon.cc.

References align::AlignableDTBarrel, align::AlignableDTChamber, align::AlignableDTStation, align::AlignableDTWheel, DTGeometry::chambers(), LogDebug, DTChamberId::station(), theDTBarrel, theDTChambers, theDTStations, theDTWheels, theMuonComponents, and DTChamberId::wheel().

Referenced by AlignableMuon(), and update().

                                                                     {
   LogDebug("Position") << "Constructing AlignableDTBarrel";
 
   // Temporary container for chambers in a given station and stations in a given wheel
   std::vector<AlignableDTChamber*> tmpDTChambersInStation;
   std::vector<AlignableDTStation*> tmpDTStationsInWheel;
 
   // Loop over wheels ( -2..2 )
   for (int iwh = -2; iwh < 3; iwh++) {
     // Loop over stations ( 1..4 )
     for (int ist = 1; ist < 5; ist++) {
       // Loop over geom DT Chambers
       int iChamber{0};
       std::vector<const GeomDet*>
           theSLs;  // FIXME: What is this vector meant to be for? Probably redundant since super layers are handled inside of the AlignableDTChamber.
       for (const auto& det : pDT->chambers()) {
         // Get the chamber ID
         DTChamberId chamberId = det->id();
 
         // Get wheel,station and sector of the chamber
         int wh = chamberId.wheel();
         int st = chamberId.station();
         //int se = chamberId.sector();
 
         // Select the chambers in a given wheel in a given station
         if (iwh == wh && ist == st) {
           if (update) {
             // Update the alignable DT chamber
             theDTBarrel.back()->wheel(iwh + 2).station(ist - 1).chamber(iChamber).update(det);
           } else {
             // Create the alignable DT chamber
             AlignableDTChamber* tmpDTChamber = new AlignableDTChamber(det);
 
             // Store the DT chambers in a given DT Station and Wheel
             tmpDTChambersInStation.push_back(tmpDTChamber);
           }
 
           ++iChamber;
           // End chamber selection
         }
 
         // End loop over chambers
       }
 
       if (!update) {
         // Store the DT chambers
         theDTChambers.insert(theDTChambers.end(), tmpDTChambersInStation.begin(), tmpDTChambersInStation.end());
 
         // Create the alignable DT station with chambers in a given station and wheel
         AlignableDTStation* tmpDTStation = new AlignableDTStation(tmpDTChambersInStation);
 
         // Store the DT stations in a given wheel
         tmpDTStationsInWheel.push_back(tmpDTStation);
 
         // Clear the temporary vector of chambers in a station
         tmpDTChambersInStation.clear();
       }
       // End loop over stations
     }
 
     if (!update) {
       // Store The DT stations
       theDTStations.insert(theDTStations.end(), tmpDTStationsInWheel.begin(), tmpDTStationsInWheel.end());
 
       // Create the alignable DT wheel
       AlignableDTWheel* tmpWheel = new AlignableDTWheel(tmpDTStationsInWheel);
 
       // Store the DT wheels
       theDTWheels.push_back(tmpWheel);
 
       // Clear temporary vector of stations in a wheel
       tmpDTStationsInWheel.clear();
     }
 
     // End loop over wheels
   }
 
   if (!update) {
     // Create the alignable Muon Barrel
     AlignableDTBarrel* tmpDTBarrel = new AlignableDTBarrel(theDTWheels);
 
     // Store the barrel
     theDTBarrel.push_back(tmpDTBarrel);
 
     // Store the barrel in the muon
     theMuonComponents.push_back(tmpDTBarrel);
   }
 }

void AlignableMuon::buildGEMEndcap	(	const GEMGeometry *	pGEM,
		bool	update = `false`
	)

private

Definition at line 283 of file AlignableMuon.cc.

References align::AlignableGEMEndcap, align::AlignableGEMRing, align::AlignableGEMStation, align::AlignableGEMSuperChamber, LogDebug, GEMDetId::region(), GEMDetId::ring(), GEMDetId::station(), GEMGeometry::superChambers(), theGEMEndcaps, theGEMRings, theGEMStations, and theGEMSuperChambers.

Referenced by AlignableMuon(), and update().

                                                                        {
   LogDebug("Position") << "Constructing AlignableGEMEndcap";
   std::vector<AlignableGEMStation*> tmpGEMStationsInEndcap;
   for (int iec = -1; iec < 2; iec = iec + 2) {
     std::vector<AlignableGEMRing*> tmpGEMRingsInStation;
 
     for (int ist = 0; ist < 3; ist++) {
       if (ist == 0)
         continue;  //Run3 GEM dosen't have ME0
       if (ist == 2)
         continue;  //Run3 GEM dosen't have GE2/1
       std::vector<AlignableGEMSuperChamber*> tmpGEMSuperChambersInRing;
       int iri = 1;
       int iChamber{0};
       auto vc = pGEM->superChambers();
       for (const auto& det : vc) {
         GEMDetId gemId = det->id();
         int ec = gemId.region();
         int st = gemId.station();
         int ri = gemId.ring();
 
         if (iec == ec && ist == st && iri == ri) {
           if (update) {
             theGEMEndcaps[iec == -1 ? 0 : 1]->station(ist - 1).ring(iri - 1).superChamber(iChamber).update(det);
           } else {
             AlignableGEMSuperChamber* tmpGEMSuperChamber = new AlignableGEMSuperChamber(det);
             tmpGEMSuperChambersInRing.push_back(tmpGEMSuperChamber);
           }
           ++iChamber;
         }
       }
       if (!update) {
         if (!tmpGEMSuperChambersInRing.empty()) {
           theGEMSuperChambers.insert(
               theGEMSuperChambers.end(), tmpGEMSuperChambersInRing.begin(), tmpGEMSuperChambersInRing.end());
           AlignableGEMRing* tmpGEMRing = new AlignableGEMRing(tmpGEMSuperChambersInRing);
           tmpGEMRingsInStation.push_back(tmpGEMRing);
           tmpGEMSuperChambersInRing.clear();
         }
       }
       if (!update) {
         AlignableGEMStation* tmpGEMStation = new AlignableGEMStation(tmpGEMRingsInStation);
         theGEMRings.insert(theGEMRings.end(), tmpGEMRingsInStation.begin(), tmpGEMRingsInStation.end());
         tmpGEMStationsInEndcap.push_back(tmpGEMStation);
         tmpGEMRingsInStation.clear();
       }
     }
     if (!update) {
       AlignableGEMEndcap* tmpEndcap = new AlignableGEMEndcap(tmpGEMStationsInEndcap);
       theGEMStations.insert(theGEMStations.end(), tmpGEMStationsInEndcap.begin(), tmpGEMStationsInEndcap.end());
       theGEMEndcaps.push_back(tmpEndcap);
       tmpGEMStationsInEndcap.clear();
     }
   }
 }

const align::Alignables& AlignableMuon::components ( ) const

inlinefinalvirtual

Return all components.

Reimplemented from AlignableComposite.

Definition at line 51 of file AlignableMuon.h.

References theMuonComponents.

Referenced by AlignableMuon(), alignmentErrors(), and alignments().

51 { return theMuonComponents; }

AlignableMuon::theMuonComponents

align::Alignables theMuonComponents

Definition: AlignableMuon.h:142

RotationType AlignableMuon::computeOrientation ( )

private

Get the global orientation (no rotation by default)

PositionType AlignableMuon::computePosition ( )

private

Get the position (centered at 0 by default)

AlignableSurface AlignableMuon::computeSurface ( )

private

Get the Surface.

AlignmentErrorsExtended * AlignableMuon::cscAlignmentErrorsExtended ( void )

Get CSC alignment errors sorted by DetId.

Definition at line 580 of file AlignableMuon.cc.

References filterCSVwithJSON::copy, CSCEndcaps(), and AlignmentErrorsExtended::m_alignError.

Referenced by MuonMisalignedProducer::analyze(), MuonAlignment::copyAlignmentToSurvey(), MuonAlignment::saveCSCtoDB(), and MuonAlignmentOutputXML::write().

                                                                        {
   // Retrieve muon endcaps alignment errors
   AlignmentErrorsExtended* cscEndCap1Errors = this->CSCEndcaps().front()->alignmentErrors();
   AlignmentErrorsExtended* cscEndCap2Errors = this->CSCEndcaps().back()->alignmentErrors();
   AlignmentErrorsExtended* tmpAlignmentErrorsExtended = new AlignmentErrorsExtended();
 
   std::copy(cscEndCap1Errors->m_alignError.begin(),
             cscEndCap1Errors->m_alignError.end(),
             back_inserter(tmpAlignmentErrorsExtended->m_alignError));
   std::copy(cscEndCap2Errors->m_alignError.begin(),
             cscEndCap2Errors->m_alignError.end(),
             back_inserter(tmpAlignmentErrorsExtended->m_alignError));
 
   return tmpAlignmentErrorsExtended;
 }

Alignments * AlignableMuon::cscAlignments ( void )

Get CSC alignments sorted by DetId.

Definition at line 568 of file AlignableMuon.cc.

References filterCSVwithJSON::copy, CSCEndcaps(), and Alignments::m_align.

Referenced by MuonMisalignedProducer::analyze(), and MuonAlignment::saveCSCtoDB().

                                              {
   // Retrieve muon endcaps alignments
   Alignments* cscEndCap1 = this->CSCEndcaps().front()->alignments();
   Alignments* cscEndCap2 = this->CSCEndcaps().back()->alignments();
   Alignments* tmpAlignments = new Alignments();
 
   std::copy(cscEndCap1->m_align.begin(), cscEndCap1->m_align.end(), back_inserter(tmpAlignments->m_align));
   std::copy(cscEndCap2->m_align.begin(), cscEndCap2->m_align.end(), back_inserter(tmpAlignments->m_align));
 
   return tmpAlignments;
 }

align::Alignables AlignableMuon::CSCChambers ( )

Definition at line 418 of file AlignableMuon.cc.

References filterCSVwithJSON::copy, mps_fire::result, and theCSCChambers.

Referenced by AlignmentParameterSelector::addSelection(), CSCLayers(), MuonAlignmentFromReference::initialize(), and MuonScenarioBuilder::moveCSCSectors().

                                            {
   align::Alignables result;
   copy(theCSCChambers.begin(), theCSCChambers.end(), back_inserter(result));
   return result;
 }

align::Alignables AlignableMuon::CSCEndcaps ( )

Definition at line 439 of file AlignableMuon.cc.

References filterCSVwithJSON::copy, mps_fire::result, and theCSCEndcaps.

Referenced by AlignmentParameterSelector::addSelection(), SurveyInputCSCfromPins::analyze(), MuonScenarioBuilder::applyScenario(), MuonAlignment::copyAlignmentToSurvey(), cscAlignmentErrorsExtended(), cscAlignments(), MuonAlignment::fillGapsInSurvey(), MuonScenarioBuilder::moveMuon(), MuonAlignmentInputSurveyDB::newAlignableMuon(), MuonAlignmentInputXML::newAlignableMuon(), MuonAlignment::saveCSCSurveyToDB(), and MuonAlignmentOutputXML::write().

                                           {
   align::Alignables result;
   copy(theCSCEndcaps.begin(), theCSCEndcaps.end(), back_inserter(result));
   return result;
 }

align::Alignables AlignableMuon::CSCLayers ( )

Definition at line 403 of file AlignableMuon.cc.

References chambers, CSCChambers(), LayerTriplets::layers(), and mps_fire::result.

Referenced by AlignmentParameterSelector::addSelection().

                                          {
   align::Alignables result;
 
   align::Alignables chambers = CSCChambers();
   for (align::Alignables::const_iterator chamberIter = chambers.begin(); chamberIter != chambers.end(); ++chamberIter) {
     align::Alignables layers = (*chamberIter)->components();
     for (align::Alignables::const_iterator layerIter = layers.begin(); layerIter != layers.end(); ++layerIter) {
       result.push_back(*layerIter);
     }
   }
 
   return result;
 }

align::Alignables AlignableMuon::CSCRings ( )

Definition at line 425 of file AlignableMuon.cc.

References filterCSVwithJSON::copy, mps_fire::result, and theCSCRings.

Referenced by AlignmentParameterSelector::addSelection().

                                         {
   align::Alignables result;
   copy(theCSCRings.begin(), theCSCRings.end(), back_inserter(result));
   return result;
 }

align::Alignables AlignableMuon::CSCStations ( )

Definition at line 432 of file AlignableMuon.cc.

References filterCSVwithJSON::copy, mps_fire::result, and theCSCStations.

Referenced by AlignmentParameterSelector::addSelection().

                                            {
   align::Alignables result;
   copy(theCSCStations.begin(), theCSCStations.end(), back_inserter(result));
   return result;
 }

AlignmentErrorsExtended * AlignableMuon::dtAlignmentErrorsExtended ( void )

Get DT alignment errors sorted by DetId.

Definition at line 561 of file AlignableMuon.cc.

References DTBarrel().

Referenced by MuonMisalignedProducer::analyze(), MuonAlignment::copyAlignmentToSurvey(), MuonAlignment::saveDTtoDB(), and MuonAlignmentOutputXML::write().

                                                                       {
   // Retrieve muon barrel alignment errors
   AlignmentErrorsExtended* tmpAlignmentErrorsExtended = this->DTBarrel().front()->alignmentErrors();
 
   return tmpAlignmentErrorsExtended;
 }

Alignments * AlignableMuon::dtAlignments ( void )

Get DT alignments sorted by DetId.

Definition at line 554 of file AlignableMuon.cc.

References DTBarrel().

Referenced by MuonMisalignedProducer::analyze(), and MuonAlignment::saveDTtoDB().

                                             {
   // Retrieve muon barrel alignments
   Alignments* tmpAlignments = this->DTBarrel().front()->alignments();
 
   return tmpAlignments;
 }

align::Alignables AlignableMuon::DTBarrel ( )

Definition at line 396 of file AlignableMuon.cc.

References filterCSVwithJSON::copy, mps_fire::result, and theDTBarrel.

Referenced by AlignmentParameterSelector::addSelection(), MuonScenarioBuilder::applyScenario(), MuonAlignment::copyAlignmentToSurvey(), dtAlignmentErrorsExtended(), dtAlignments(), MuonAlignment::fillGapsInSurvey(), MuonScenarioBuilder::moveMuon(), MuonAlignmentInputSurveyDB::newAlignableMuon(), MuonAlignmentInputXML::newAlignableMuon(), MuonAlignment::saveDTSurveyToDB(), and MuonAlignmentOutputXML::write().

                                         {
   align::Alignables result;
   copy(theDTBarrel.begin(), theDTBarrel.end(), back_inserter(result));
   return result;
 }

align::Alignables AlignableMuon::DTChambers ( )

Definition at line 375 of file AlignableMuon.cc.

References filterCSVwithJSON::copy, mps_fire::result, and theDTChambers.

Referenced by AlignmentParameterSelector::addSelection(), DTLayers(), DTSuperLayers(), MuonAlignmentFromReference::initialize(), and MuonScenarioBuilder::moveDTSectors().

                                           {
   align::Alignables result;
   copy(theDTChambers.begin(), theDTChambers.end(), back_inserter(result));
   return result;
 }

align::Alignables AlignableMuon::DTLayers ( )

Methods to return specific of components.

Definition at line 340 of file AlignableMuon.cc.

References chambers, DTChambers(), LayerTriplets::layers(), and mps_fire::result.

Referenced by AlignmentParameterSelector::addSelection().

                                         {
   align::Alignables result;
 
   align::Alignables chambers = DTChambers();
   for (align::Alignables::const_iterator chamberIter = chambers.begin(); chamberIter != chambers.end(); ++chamberIter) {
     align::Alignables superlayers = (*chamberIter)->components();
     for (align::Alignables::const_iterator superlayerIter = superlayers.begin(); superlayerIter != superlayers.end();
          ++superlayerIter) {
       align::Alignables layers = (*superlayerIter)->components();
       for (align::Alignables::const_iterator layerIter = layers.begin(); layerIter != layers.end(); ++layerIter) {
         result.push_back(*layerIter);
       }
     }
   }
 
   return result;
 }

align::Alignables AlignableMuon::DTStations ( )

Definition at line 382 of file AlignableMuon.cc.

References filterCSVwithJSON::copy, mps_fire::result, and theDTStations.

Referenced by AlignmentParameterSelector::addSelection().

                                           {
   align::Alignables result;
   copy(theDTStations.begin(), theDTStations.end(), back_inserter(result));
   return result;
 }

align::Alignables AlignableMuon::DTSuperLayers ( )

Definition at line 359 of file AlignableMuon.cc.

References chambers, DTChambers(), and mps_fire::result.

Referenced by AlignmentParameterSelector::addSelection().

                                              {
   align::Alignables result;
 
   align::Alignables chambers = DTChambers();
   for (align::Alignables::const_iterator chamberIter = chambers.begin(); chamberIter != chambers.end(); ++chamberIter) {
     align::Alignables superlayers = (*chamberIter)->components();
     for (align::Alignables::const_iterator superlayerIter = superlayers.begin(); superlayerIter != superlayers.end();
          ++superlayerIter) {
       result.push_back(*superlayerIter);
     }
   }
 
   return result;
 }

align::Alignables AlignableMuon::DTWheels ( )

Definition at line 389 of file AlignableMuon.cc.

References filterCSVwithJSON::copy, mps_fire::result, and theDTWheels.

Referenced by AlignmentParameterSelector::addSelection().

                                         {
   align::Alignables result;
   copy(theDTWheels.begin(), theDTWheels.end(), back_inserter(result));
   return result;
 }

AlignmentErrorsExtended * AlignableMuon::gemAlignmentErrorsExtended ( void )

Definition at line 608 of file AlignableMuon.cc.

References filterCSVwithJSON::copy, GEMEndcaps(), and AlignmentErrorsExtended::m_alignError.

Referenced by MuonMisalignedProducer::analyze(), MuonAlignment::copyAlignmentToSurvey(), MuonAlignment::saveGEMtoDB(), and MuonAlignmentOutputXML::write().

                                                                        {
   // Retrieve muon endcaps alignment errors
   AlignmentErrorsExtended* gemEndCap1Errors = this->GEMEndcaps().front()->alignmentErrors();
   AlignmentErrorsExtended* gemEndCap2Errors = this->GEMEndcaps().back()->alignmentErrors();
   AlignmentErrorsExtended* tmpAlignmentErrorsExtended = new AlignmentErrorsExtended();
 
   std::copy(gemEndCap1Errors->m_alignError.begin(),
             gemEndCap1Errors->m_alignError.end(),
             back_inserter(tmpAlignmentErrorsExtended->m_alignError));
   std::copy(gemEndCap2Errors->m_alignError.begin(),
             gemEndCap2Errors->m_alignError.end(),
             back_inserter(tmpAlignmentErrorsExtended->m_alignError));
   std::sort(tmpAlignmentErrorsExtended->m_alignError.begin(), tmpAlignmentErrorsExtended->m_alignError.end());
 
   return tmpAlignmentErrorsExtended;
 }

Alignments * AlignableMuon::gemAlignments ( void )

Definition at line 597 of file AlignableMuon.cc.

References filterCSVwithJSON::copy, GEMEndcaps(), and Alignments::m_align.

Referenced by MuonMisalignedProducer::analyze(), and MuonAlignment::saveGEMtoDB().

                                              {
   Alignments* gemEndCap1 = this->GEMEndcaps().front()->alignments();
   Alignments* gemEndCap2 = this->GEMEndcaps().back()->alignments();
   Alignments* tmpAlignments = new Alignments();
   std::copy(gemEndCap1->m_align.begin(), gemEndCap1->m_align.end(), back_inserter(tmpAlignments->m_align));
   std::copy(gemEndCap2->m_align.begin(), gemEndCap2->m_align.end(), back_inserter(tmpAlignments->m_align));
   std::sort(tmpAlignments->m_align.begin(), tmpAlignments->m_align.end());
 
   return tmpAlignments;
 }

align::Alignables AlignableMuon::GEMChambers ( )

Definition at line 467 of file AlignableMuon.cc.

References chambers, GEMSuperChambers(), and mps_fire::result.

                                            {
   align::Alignables result;
   align::Alignables superChambers = GEMSuperChambers();
   for (align::Alignables::const_iterator superChamberIter = superChambers.begin();
        superChamberIter != superChambers.end();
        ++superChamberIter) {
     align::Alignables chambers = (*superChamberIter)->components();
     for (align::Alignables::const_iterator chamberIter = chambers.begin(); chamberIter != chambers.end();
          ++chamberIter) {
       result.push_back(*chamberIter);
     }
   }
   return result;
 }

align::Alignables AlignableMuon::GEMEndcaps ( )

Definition at line 504 of file AlignableMuon.cc.

References filterCSVwithJSON::copy, mps_fire::result, and theGEMEndcaps.

Referenced by MuonScenarioBuilder::applyScenario(), MuonAlignment::copyAlignmentToSurvey(), gemAlignmentErrorsExtended(), gemAlignments(), MuonScenarioBuilder::moveMuon(), MuonAlignmentInputXML::newAlignableMuon(), and MuonAlignmentOutputXML::write().

                                           {
   align::Alignables result;
   copy(theGEMEndcaps.begin(), theGEMEndcaps.end(), back_inserter(result));
   return result;
 }

align::Alignables AlignableMuon::GEMEtaPartitions ( )

Definition at line 446 of file AlignableMuon.cc.

References chambers, GEMSuperChambers(), and mps_fire::result.

                                                 {
   align::Alignables result;
   align::Alignables superChambers = GEMSuperChambers();
   for (align::Alignables::const_iterator superChamberIter = superChambers.begin();
        superChamberIter != superChambers.end();
        ++superChamberIter) {
     align::Alignables chambers = (*superChamberIter)->components();
     for (align::Alignables::const_iterator chamberIter = chambers.begin(); chamberIter != chambers.end();
          ++chamberIter) {
       align::Alignables etaPartitions = (*chamberIter)->components();
       for (align::Alignables::const_iterator etaPartitionIter = etaPartitions.begin();
            etaPartitionIter != etaPartitions.end();
            ++etaPartitionIter) {
         result.push_back(*etaPartitionIter);
       }
     }
   }
   return result;
 }

align::Alignables AlignableMuon::GEMRings ( )

Definition at line 490 of file AlignableMuon.cc.

References filterCSVwithJSON::copy, mps_fire::result, and theGEMRings.

                                         {
   align::Alignables result;
   copy(theGEMRings.begin(), theGEMRings.end(), back_inserter(result));
   return result;
 }

align::Alignables AlignableMuon::GEMStations ( )

Definition at line 497 of file AlignableMuon.cc.

References filterCSVwithJSON::copy, mps_fire::result, and theGEMStations.

                                            {
   align::Alignables result;
   copy(theGEMStations.begin(), theGEMStations.end(), back_inserter(result));
   return result;
 }

align::Alignables AlignableMuon::GEMSuperChambers ( )

Definition at line 483 of file AlignableMuon.cc.

References filterCSVwithJSON::copy, mps_fire::result, and theGEMSuperChambers.

Referenced by GEMChambers(), GEMEtaPartitions(), and MuonScenarioBuilder::moveGEMSectors().

                                                 {
   align::Alignables result;
   copy(theGEMSuperChambers.begin(), theGEMSuperChambers.end(), back_inserter(result));
   return result;
 }

virtual Alignable* AlignableMuon::mother ( )

inlinevirtual

Alignable tracker has no mother.

Definition at line 54 of file AlignableMuon.h.

54 { return nullptr; }

const AlignableObjectId& AlignableMuon::objectIdProvider ( ) const

inline

Return muon alignable object ID provider derived from the muon system geometry.

Definition at line 92 of file AlignableMuon.h.

References alignableObjectId_.

Referenced by MuonAlignmentInputXML::newAlignableMuon(), and MuonAlignmentOutputXML::write().

92 { return alignableObjectId_; }

AlignableMuon::alignableObjectId_

const AlignableObjectId alignableObjectId_

alignable object ID provider

Definition: AlignableMuon.h:124

void AlignableMuon::recursiveSetMothers ( Alignable * alignable )

private

Set mothers recursively.

Definition at line 511 of file AlignableMuon.cc.

References Alignable::components().

Referenced by AlignableMuon().

                                                             {
   for (const auto& iter : alignable->components()) {
     iter->setMother(alignable);
     recursiveSetMothers(iter);
   }
 }

void AlignableMuon::update	(	const DTGeometry *	dtGeometry,
		const CSCGeometry *	cscGeometry,
		const GEMGeometry *	gemGeometry
	)

Updater using DTGeometry and CSCGeometry. The given geometries have to match the current ones.

Definition at line 65 of file AlignableMuon.cc.

References buildCSCEndcap(), buildDTBarrel(), and buildGEMEndcap().

Referenced by progressbar.ProgressBar::__next__(), MatrixUtil.Matrix::__setitem__(), MatrixUtil.Steps::__setitem__(), dqm-mbProfile.Profile::finish(), progressbar.ProgressBar::finish(), and MatrixUtil.Steps::overwrite().

                                                            {
   // update the muon barrel
   buildDTBarrel(dtGeometry, /* update = */ true);
 
   // update the muon end caps
   buildCSCEndcap(cscGeometry, /* update = */ true);
   buildGEMEndcap(gemGeometry, /* update = */ true);
 
   edm::LogInfo("Alignment") << "@SUB=AlignableMuon::update"
                             << "Updating alignable muon objects DONE";
 }