#include <GlobalTrackingGeometry.h>

Inheritance diagram for GlobalTrackingGeometry:

Public Member Functions
virtual const DetIdContainer &	detIds () const
	Returm a vector of all GeomDet DetIds (including those of GeomDetUnits) More...

virtual const DetContainer &	dets () const
	Returm a vector of all GeomDet (including all GeomDetUnits) More...

virtual const DetTypeContainer &	detTypes () const
	Return a vector of all det types. More...

virtual const DetIdContainer &	detUnitIds () const
	Returm a vector of all GeomDetUnit DetIds. More...

virtual const DetUnitContainer &	detUnits () const
	Returm a vector of all GeomDetUnit. More...

	GlobalTrackingGeometry (std::vector< const TrackingGeometry * > &geos)
	Constructor. More...

virtual const GeomDet *	idToDet (DetId) const

virtual const GeomDetUnit *	idToDetUnit (DetId) const
	Return the pointer to the GeomDetUnit corresponding to a given DetId. More...

const TrackingGeometry *	slaveGeometry (DetId id) const
	Return the pointer to the actual geometry for a given DetId. More...

virtual	~GlobalTrackingGeometry ()
	Destructor. More...

Public Member Functions inherited from TrackingGeometry
virtual	~TrackingGeometry ()
	Destructor. More...

Private Attributes
std::atomic< DetIdContainer * >	theDetIds

std::atomic< DetContainer * >	theDets

std::atomic< DetTypeContainer * >	theDetTypes

std::atomic< DetIdContainer * >	theDetUnitIds

std::atomic< DetUnitContainer * >	theDetUnits

std::vector< const TrackingGeometry * >	theGeometries

Additional Inherited Members
Public Types inherited from TrackingGeometry
typedef std::vector< GeomDet * >	DetContainer

typedef std::vector< DetId >	DetIdContainer

typedef std::vector < GeomDetType * >	DetTypeContainer

typedef std::vector < GeomDetUnit * >	DetUnitContainer

typedef __gnu_cxx::hash_map < unsigned int, GeomDet * >	mapIdToDet

typedef __gnu_cxx::hash_map < unsigned int, GeomDetUnit * >	mapIdToDetUnit

Detailed Description

Single entry point to the tracker and muon geometries. The main purpose is to provide the methods idToDetUnit(DetId) and idToDet(DetId) that allow to get an element of the geometry given its DetId, regardless of wich subdetector it belongs.

The slave geometries (TrackerGeometry, DTGeometry, CSCGeometry, RPCGeometry) are accessible with the method slaveGeometry(DetId).

Author: M. Sani

ESProducer for GlobalTrackingGeometry in MuonGeometryRecord

Author: Matteo Sani

Definition at line 20 of file GlobalTrackingGeometry.h.

Constructor & Destructor Documentation

GlobalTrackingGeometry::GlobalTrackingGeometry ( std::vector< const TrackingGeometry * > & geos )

Constructor.

Definition at line 10 of file GlobalTrackingGeometry.cc.

     : theGeometries(geos),
     theDetTypes(nullptr), theDetUnits(nullptr), theDets(nullptr), theDetUnitIds(nullptr), theDetIds(nullptr)
 {}

GlobalTrackingGeometry::~GlobalTrackingGeometry ( )

virtual

Destructor.

Definition at line 15 of file GlobalTrackingGeometry.cc.

References theDetIds, theDets, theDetTypes, theDetUnitIds, and theDetUnits.

 {
     delete theDetTypes;
     theDetTypes = nullptr;
     delete theDetUnits;
     theDetUnits = nullptr;
     delete theDets;
     theDets = nullptr;
     delete theDetUnitIds;
     theDetUnitIds = nullptr;
     delete theDetIds;
     theDetIds = nullptr;
 }

Member Function Documentation

const TrackingGeometry::DetIdContainer & GlobalTrackingGeometry::detIds ( ) const

virtual

Returm a vector of all GeomDet DetIds (including those of GeomDetUnits)

Implements TrackingGeometry.

Definition at line 150 of file GlobalTrackingGeometry.cc.

References relativeConstraints::geom, theDetIds, and theGeometries.

 {
    if (!theDetIds.load(std::memory_order_acquire)) {
        std::unique_ptr<DetIdContainer> ptr{new DetIdContainer()};
        for( auto geom = theGeometries.cbegin(), geomEnd = theGeometries.cend(); geom != geomEnd; ++geom )
        {
         if( *geom == 0 ) continue;
         DetIdContainer detIds(( *geom )->detIds());
         if( detIds.size() + ptr->size() < ptr->capacity()) ptr->resize( detIds.size() + ptr->size());
         for( auto detId = detIds.cbegin(), detIdEnd = detIds.cend(); detId != detIdEnd; ++detId )
           ptr->push_back( *detId );
        }
        DetIdContainer* expect = nullptr;
        if(theDetIds.compare_exchange_strong(expect, ptr.get(), std::memory_order_acq_rel)) {
            ptr.release();
        }
    }
    return *theDetIds.load(std::memory_order_acquire);
 }

const TrackingGeometry::DetContainer & GlobalTrackingGeometry::dets ( ) const

virtual

Returm a vector of all GeomDet (including all GeomDetUnits)

Implements TrackingGeometry.

Definition at line 108 of file GlobalTrackingGeometry.cc.

References relativeConstraints::geom, theDets, and theGeometries.

 {
    if (!theDets.load(std::memory_order_acquire)) {
        std::unique_ptr<DetContainer> ptr{new DetContainer()};
        for( auto geom = theGeometries.cbegin(), geomEnd = theGeometries.cend(); geom != geomEnd; ++geom )
        {
         if( *geom == 0 ) continue;
         DetContainer dets(( *geom )->dets());
         if( dets.size() + ptr->size() < ptr->capacity()) ptr->resize( dets.size() + ptr->size());
         for( auto det = dets.cbegin(), detEnd = dets.cend(); det != detEnd; ++det )
           ptr->push_back( *det );
        }
        DetContainer* expect = nullptr;
        if(theDets.compare_exchange_strong(expect, ptr.get(), std::memory_order_acq_rel)) {
            ptr.release();
        }
    }
    return *theDets.load(std::memory_order_acquire);
 }

const TrackingGeometry::DetTypeContainer & GlobalTrackingGeometry::detTypes ( ) const

virtual

Return a vector of all det types.

Implements TrackingGeometry.

Definition at line 66 of file GlobalTrackingGeometry.cc.

References relativeConstraints::geom, theDetTypes, and theGeometries.

 {    
    if (!theDetTypes.load(std::memory_order_acquire)) {
        std::unique_ptr<DetTypeContainer> ptr{new DetTypeContainer()};
        for( auto geom = theGeometries.cbegin(), geomEnd = theGeometries.cend(); geom != geomEnd; ++geom )
        {
         if( *geom == 0 ) continue;
         DetTypeContainer detTypes(( *geom )->detTypes());
         if( detTypes.size() + ptr->size() < ptr->capacity()) ptr->resize( detTypes.size() + ptr->size());
         for( auto detType = detTypes.cbegin(), detTypeEnd = detTypes.cend(); detType != detTypeEnd; ++detType )
           ptr->push_back( *detType );
        }
        DetTypeContainer* expect = nullptr;
        if(theDetTypes.compare_exchange_strong(expect, ptr.get(), std::memory_order_acq_rel)) {
            ptr.release();
        }
    }
    return *theDetTypes.load(std::memory_order_acquire);
 }

const TrackingGeometry::DetIdContainer & GlobalTrackingGeometry::detUnitIds ( ) const

virtual

Returm a vector of all GeomDetUnit DetIds.

Implements TrackingGeometry.

Definition at line 129 of file GlobalTrackingGeometry.cc.

References relativeConstraints::geom, theDetUnitIds, and theGeometries.

 {
    if (!theDetUnitIds.load(std::memory_order_acquire)) {
        std::unique_ptr<DetIdContainer> ptr{new DetIdContainer()};
        for( auto geom = theGeometries.cbegin(), geomEnd = theGeometries.cend(); geom != geomEnd; ++geom )
        {
         if( *geom == 0 ) continue;
         DetIdContainer detUnitIds(( *geom )->detUnitIds());
         if( detUnitIds.size() + ptr->size() < ptr->capacity()) ptr->resize( detUnitIds.size() + ptr->size());
         for( auto detUnitId = detUnitIds.cbegin(), detUnitIdEnd = detUnitIds.cend(); detUnitId != detUnitIdEnd; ++detUnitId )
           ptr->push_back( *detUnitId );
        }
        DetIdContainer* expect = nullptr;
        if(theDetUnitIds.compare_exchange_strong(expect, ptr.get(), std::memory_order_acq_rel)) {
            ptr.release();
        }
    }
    return *theDetUnitIds.load(std::memory_order_acquire);
 }

const TrackingGeometry::DetUnitContainer & GlobalTrackingGeometry::detUnits ( ) const

virtual

Returm a vector of all GeomDetUnit.

Implements TrackingGeometry.

Definition at line 87 of file GlobalTrackingGeometry.cc.

References relativeConstraints::geom, theDetUnits, and theGeometries.

 {
    if (!theDetUnits.load(std::memory_order_acquire)) {
        std::unique_ptr<DetUnitContainer> ptr{new DetUnitContainer()};
        for( auto geom = theGeometries.cbegin(), geomEnd = theGeometries.cend(); geom != geomEnd; ++geom )
        {
         if( *geom == 0 ) continue;
         DetUnitContainer detUnits(( *geom )->detUnits());
         if( detUnits.size() + ptr->size() < ptr->capacity()) ptr->resize( detUnits.size() + ptr->size());
         for( auto detUnit = detUnits.cbegin(), detUnitEnd = detUnits.cend(); detUnit != detUnitEnd; ++detUnit )
           ptr->push_back( *detUnit );
        }
        DetUnitContainer* expect = nullptr;
        if(theDetUnits.compare_exchange_strong(expect, ptr.get(), std::memory_order_acq_rel)) {
            ptr.release();
        }
    }
    return *theDetUnits.load(std::memory_order_acquire);
 }

const GeomDet * GlobalTrackingGeometry::idToDet ( DetId ) const

virtual

Return the pointer to the GeomDet corresponding to a given DetId (valid also for GeomDetUnits)

Implements TrackingGeometry.

Definition at line 41 of file GlobalTrackingGeometry.cc.

References TrackingGeometry::idToDet(), and slaveGeometry().

Referenced by CSCTimingExtractor::fillTiming(), DTTimingExtractor::fillTiming(), MuonDetIdAssociator::getDetIdPoints(), MuonDetIdAssociator::getGeomDet(), and MuonDetIdAssociator::insideElement().

                                                             {
   
     const TrackingGeometry* tg = slaveGeometry(id);
     
     if (tg != 0) {
         return tg->idToDet(id);
     } else {
       return 0;
     }
 }

const GeomDetUnit * GlobalTrackingGeometry::idToDetUnit ( DetId ) const

virtual

Return the pointer to the GeomDetUnit corresponding to a given DetId.

Implements TrackingGeometry.

Definition at line 29 of file GlobalTrackingGeometry.cc.

References TrackingGeometry::idToDetUnit(), and slaveGeometry().

                                                                      {
     
     const TrackingGeometry* tg = slaveGeometry(id);
     
     if (tg != 0) {
       return tg->idToDetUnit(id);
     } else {
       return 0;
     }
 }

const TrackingGeometry * GlobalTrackingGeometry::slaveGeometry ( DetId id ) const

Return the pointer to the actual geometry for a given DetId.

Definition at line 52 of file GlobalTrackingGeometry.cc.

References edm::hlt::Exception, customizeTrackingMonitorSeedNumber::idx, DetId::Muon, and theGeometries.

Referenced by MuonDetIdAssociator::getValidDetIds(), idToDet(), and idToDetUnit().

                                                                             {  
   
     int idx = id.det()-1;
     if (id.det() == DetId::Muon) {
         
         idx+=id.subdetId()-1;
     }
 
     if (theGeometries[idx]==0) throw cms::Exception("NoGeometry") << "No Tracking Geometry is available for DetId " << id.rawId() << std::endl;
 
     return theGeometries[idx];
 }