DTReadOutMapping Class Reference

#include <DTReadOutMapping.h>

Public Types
typedef std::vector < DTReadOutGeometryLink > ::const_iterator	const_iterator
	Access methods to the connections. More...
enum	type { plain, compact }

Public Member Functions
const_iterator	begin () const
void	clear ()
	clear map More...
	DTReadOutMapping ()
	DTReadOutMapping (const std::string &cell_map_version, const std::string &rob_map_version)
const_iterator	end () const
const DTReadOutMapping *	fullMap () const
	Expand to full map. More...
int	geometryToReadOut (int wheelId, int stationId, int sectorId, int slId, int layerId, int cellId, int &dduId, int &rosId, int &robId, int &tdcId, int &channelId) const
int	geometryToReadOut (const DTWireId &wireId, int &dduId, int &rosId, int &robId, int &tdcId, int &channelId) const
int	insertReadOutGeometryLink (int dduId, int rosId, int robId, int tdcId, int channelId, int wheelId, int stationId, int sectorId, int slId, int layerId, int cellId)
	insert connection More...
const std::string &	mapCellTdc () const
	access parent maps identifiers More...
std::string &	mapCellTdc ()
const std::string &	mapRobRos () const
std::string &	mapRobRos ()
type	mapType () const
int	readOutToGeometry (int dduId, int rosId, int robId, int tdcId, int channelId, DTWireId &wireId) const
	transform identifiers More...
int	readOutToGeometry (int dduId, int rosId, int robId, int tdcId, int channelId, int &wheelId, int &stationId, int &sectorId, int &slId, int &layerId, int &cellId) const
	~DTReadOutMapping ()

Private Member Functions
edm::AtomicPtrCache < DTReadOutMappingCache > const &	atomicCache () const
edm::AtomicPtrCache < DTReadOutMappingCache > &	atomicCache ()
void	cacheMap () const
	read and store full content More...
	DTReadOutMapping (DTReadOutMapping const &)
std::string	mapNameGR () const
std::string	mapNameRG () const
DTReadOutMapping &	operator= (DTReadOutMapping const &)
template<class Archive >
void	serialize (Archive &ar, const unsigned int version)

Static Private Member Functions
static DTReadOutMapping *	expandMap (const DTReadOutMapping &compMap)

Private Attributes
edm::AtomicPtrCache < DTReadOutMappingCache >	atomicCache_
std::string	cellMapVersion
edm::ConstRespectingPtr < DTBufferTree< int, int > >	grBuf
std::vector < DTReadOutGeometryLink >	readOutChannelDriftTubeMap
edm::ConstRespectingPtr < DTBufferTree< int, int > >	rgBuf
std::string	robMapVersion

Friends
class	boost::serialization::access
template<typename CondSerializationT , typename Enabled >
struct	cond::serialization::access

Detailed Description

Description: Class to map read-out channels to physical drift tubes Many details related to this class are described in internal note IN 2010_033. In particular the compact format is described there.

Author

Paolo Ronchese INFN Padova

Definition at line 66 of file DTReadOutMapping.h.

Member Typedef Documentation

typedef std::vector<DTReadOutGeometryLink>::const_iterator DTReadOutMapping::const_iterator

Access methods to the connections.

Definition at line 149 of file DTReadOutMapping.h.

Member Enumeration Documentation

enum DTReadOutMapping::type

Enumerator
plain
compact

Definition at line 80 of file DTReadOutMapping.h.

{ plain, compact };

Constructor & Destructor Documentation

DTReadOutMapping::DTReadOutMapping

(

)

Constructor

Definition at line 34 of file DTReadOutMapping.cc.

References readOutChannelDriftTubeMap.

Referenced by expandMap().

                                  :
  cellMapVersion( " " ),
  robMapVersion( " " ),
  rgBuf(new DTBufferTree<int,int>),
  grBuf(new DTBufferTree<int,int>) {

  readOutChannelDriftTubeMap.reserve( 2000 );
}

DTReadOutMapping::DTReadOutMapping	(	const std::string &	cell_map_version,
		const std::string &	rob_map_version
	)

Definition at line 44 of file DTReadOutMapping.cc.

References readOutChannelDriftTubeMap.

                                                                       :
  cellMapVersion( cell_map_version ),
  robMapVersion(  rob_map_version ),
  rgBuf(new DTBufferTree<int,int>),
  grBuf(new DTBufferTree<int,int>) {

  readOutChannelDriftTubeMap.reserve( 2000 );
}

DTReadOutMapping::~DTReadOutMapping

(

)

Destructor

Definition at line 72 of file DTReadOutMapping.cc.

                                    {
}

DTReadOutMapping::DTReadOutMapping ( DTReadOutMapping const &  )

private

Member Function Documentation

edm::AtomicPtrCache<DTReadOutMappingCache> const& DTReadOutMapping::atomicCache ( ) const

inlineprivate

Definition at line 161 of file DTReadOutMapping.h.

References atomicCache_.

Referenced by cacheMap(), clear(), geometryToReadOut(), insertReadOutGeometryLink(), mapType(), and readOutToGeometry().

{ return atomicCache_; }

edm::AtomicPtrCache<DTReadOutMappingCache>& DTReadOutMapping::atomicCache ( )

inlineprivate

Definition at line 162 of file DTReadOutMapping.h.

References atomicCache_.

{ return atomicCache_; }

DTReadOutMapping::const_iterator DTReadOutMapping::begin

(

void

)

const

Definition at line 463 of file DTReadOutMapping.cc.

References readOutChannelDriftTubeMap.

Referenced by expandMap().

                                                             {
  return readOutChannelDriftTubeMap.begin();
}

void DTReadOutMapping::cacheMap ( ) const

private

read and store full content

Definition at line 580 of file DTReadOutMapping.cc.

References atomicCache(), DTReadOutGeometryLink::cellId, DTReadOutGeometryLink::channelId, DTReadOutGeometryLink::dduId, relval_steps::key, DTReadOutGeometryLink::layerId, MainPageGenerator::link, eostools::move(), readOutChannelDriftTubeMap, DTReadOutGeometryLink::robId, DTReadOutGeometryLink::rosId, DTReadOutGeometryLink::sectorId, edm::AtomicPtrCache< T >::set(), DTReadOutGeometryLink::stationId, and DTReadOutGeometryLink::wheelId.

Referenced by geometryToReadOut(), mapType(), and readOutToGeometry().

                                      {

  std::unique_ptr<DTReadOutMappingCache> localCache(new DTReadOutMappingCache);

  localCache->mType.insert( 0, 0 );

  int entryNum = 0;
  int entryMax = readOutChannelDriftTubeMap.size();
  std::vector<int> cellKey;
  cellKey.reserve(6);
  std::vector<int> chanKey;
  chanKey.reserve(5);
  int defaultValue = 0;
  int key;
  int val;
  int rosMapKey = 0;
  int robMapKey = 0;
  std::map<int,std::vector<int>*> dduEntries;
  for ( entryNum = 0; entryNum < entryMax; entryNum++ ) {

    const DTReadOutGeometryLink& link( readOutChannelDriftTubeMap[entryNum] );

    key = link.dduId;
    val = link.stationId;
    if ( key > 0x3fffffff ) {
      if ( link.  tdcId > 0x3fffffff ) {
        localCache->mType.insert( 0, defaultValue = link.  tdcId );
        rosMapKey = key;
      }
      else {
        localCache->mType.insert( 0, defaultValue = link.wheelId );
        robMapKey = key;
      }
    }

    if ( defaultValue == 0 ) {

      chanKey.clear();
      chanKey.push_back( link.    dduId );
      chanKey.push_back( link.    rosId );
      chanKey.push_back( link.    robId );
      chanKey.push_back( link.    tdcId );
      chanKey.push_back( link.channelId );

      localCache->rgBuf.insert( chanKey.begin(), chanKey.end(), entryNum );

      cellKey.clear();
      cellKey.push_back( link.  wheelId );
      cellKey.push_back( link.stationId );
      cellKey.push_back( link. sectorId );
      cellKey.push_back( link.     slId );
      cellKey.push_back( link.  layerId );
      cellKey.push_back( link.   cellId );

      localCache->grBuf.insert( cellKey.begin(), cellKey.end(), entryNum );

    }

    if ( key == robMapKey ) {

      chanKey.clear();
      chanKey.push_back( link.    rosId );
      chanKey.push_back( link.    tdcId );
      chanKey.push_back( link.channelId );
      localCache->rgROB.insert( chanKey.begin(), chanKey.end(), entryNum );

      cellKey.clear();
      cellKey.push_back( link. cellId );
      cellKey.push_back( link.layerId );
      cellKey.push_back( link.   slId );
      std::vector<int>* robMLgr;
      localCache->grROB.find( cellKey.begin(), cellKey.end(), robMLgr );
      if ( robMLgr == 0 ) {
        std::unique_ptr<std::vector<int> > newVector(new std::vector<int>);
        robMLgr = newVector.get();
        localCache->grROB.insert( cellKey.begin(), cellKey.end(),
                                  std::move(newVector));
      }
      robMLgr->push_back( entryNum );
    }

    if ( key == rosMapKey ) {

      chanKey.clear();
      chanKey.push_back( link.rosId );
      chanKey.push_back( link.robId );
      localCache->rgROS.insert( chanKey.begin(), chanKey.end(), entryNum );

      cellKey.clear();
      cellKey.push_back( link.   cellId );
      cellKey.push_back( link.stationId );
      std::vector<int>* rosMLgr;
      localCache->grROS.find( cellKey.begin(), cellKey.end(), rosMLgr );
      if ( rosMLgr == 0 ) {
        std::unique_ptr<std::vector<int> > newVector(new std::vector<int>);
        rosMLgr = newVector.get();
        localCache->grROS.insert( cellKey.begin(), cellKey.end(),
                                  std::move(newVector));
      }
      rosMLgr->push_back( entryNum );
    }

    if ( ( key < 0x3fffffff ) &&
         ( val > 0x3fffffff ) ) {

      chanKey.clear();
      chanKey.push_back( link.dduId );
      chanKey.push_back( link.rosId );
      localCache->rgDDU.insert( chanKey.begin(), chanKey.end(), entryNum );

      int mapId = link.cellId;
      std::vector<int>* dduMLgr;
      std::map<int,std::vector<int>*>::const_iterator dduEntIter =
                                       dduEntries.find( mapId );
      if ( dduEntIter == dduEntries.end() )
           dduEntries.insert( std::pair<int,std::vector<int>*>( mapId,
                               dduMLgr = new std::vector<int> ) );
      else                     dduMLgr = dduEntIter->second;
      dduMLgr->push_back( entryNum );

    }

  }

  if ( defaultValue != 0 ) {
    for ( entryNum = 0; entryNum < entryMax; entryNum++ ) {
      const DTReadOutGeometryLink& link( 
            readOutChannelDriftTubeMap[entryNum] );
      key = link.dduId;
      if ( key != rosMapKey ) continue;
      int    mapId = link.   rosId;
      int  whchkId = link. wheelId;
      int secchkId = link.sectorId;

      std::vector<int>* dduMLgr;
      std::map<int,std::vector<int>*>::const_iterator dduEntIter =
                                       dduEntries.find( mapId );
      if ( dduEntIter != dduEntries.end() ) dduMLgr = dduEntIter->second;
      else                                  continue;
      std::vector<int>::const_iterator dduIter = dduMLgr->begin();
      std::vector<int>::const_iterator dduIend = dduMLgr->end();
      while( dduIter != dduIend ) {
        int ientry = *dduIter++;
        const DTReadOutGeometryLink& lros(
              readOutChannelDriftTubeMap[ientry] );
        int  wheelId =  whchkId;
        int sectorId = secchkId;
        if (  wheelId == defaultValue )  wheelId = lros. wheelId;
        if ( sectorId == defaultValue ) sectorId = lros.sectorId;
        cellKey.clear();
        cellKey.push_back(    mapId );
        cellKey.push_back(  wheelId );
        cellKey.push_back( sectorId );
        std::vector<int>* dduMLgr = 0;
        localCache->grDDU.find( cellKey.begin(), cellKey.end(), dduMLgr );
        if ( dduMLgr == 0 ) {
          std::unique_ptr<std::vector<int> > newVector(new std::vector<int>);
          dduMLgr = newVector.get();
          localCache->grDDU.insert( cellKey.begin(), cellKey.end(),
                                    std::move(newVector) );
        }
        dduMLgr->push_back( ientry );
      }
    }

    std::map<int,std::vector<int>*>::const_iterator dduEntIter =
                                                    dduEntries.begin();
    std::map<int,std::vector<int>*>::const_iterator dduEntIend =
                                                    dduEntries.end();
    while ( dduEntIter != dduEntIend ) {
      const std::pair<int,std::vector<int>*>& dduEntry = *dduEntIter++;
      delete dduEntry.second;
    }

    localCache->rgBuf.clear();
    localCache->grBuf.clear();
  }

  atomicCache().set(std::move(localCache));

  return;
}

void DTReadOutMapping::clear

(

void

)

clear map

Definition at line 391 of file DTReadOutMapping.cc.

References atomicCache(), DTBufferTree< Key, Content >::clear(), grBuf, readOutChannelDriftTubeMap, edm::AtomicPtrCache< T >::reset(), and rgBuf.

Referenced by Vispa.Views.WidgetView.WidgetView::closeEvent(), Vispa.Views.BoxDecayView.BoxDecayView::closeEvent(), Vispa.Share.FindAlgorithm.FindAlgorithm::findUsingFindDialog(), Vispa.Views.LineDecayView.LineDecayView::setDataObjects(), Vispa.Views.WidgetView.WidgetView::setDataObjects(), BeautifulSoup.Tag::setString(), Vispa.Views.TreeView.TreeView::updateContent(), Vispa.Views.TableView.TableView::updateContent(), Vispa.Views.BoxDecayView.BoxDecayView::updateContent(), and Vispa.Views.PropertyView.PropertyView::updateContent().

                             {
  atomicCache().reset();
  rgBuf->clear();
  grBuf->clear();
  readOutChannelDriftTubeMap.clear();
  return;
}

DTReadOutMapping::const_iterator DTReadOutMapping::end

(

void

)

const

Definition at line 468 of file DTReadOutMapping.cc.

References readOutChannelDriftTubeMap.

Referenced by Types.LuminosityBlockRange::cppID(), Types.EventRange::cppID(), and expandMap().

                                                           {
  return readOutChannelDriftTubeMap.end();
}

DTReadOutMapping * DTReadOutMapping::expandMap ( const DTReadOutMapping &  compMap )

staticprivate

Definition at line 481 of file DTReadOutMapping.cc.

References begin(), DTReadOutGeometryLink::cellId, DTReadOutGeometryLink::channelId, gather_cfg::cout, DTReadOutGeometryLink::dduId, def, DTReadOutMapping(), end(), fullMap(), insertReadOutGeometryLink(), DTReadOutGeometryLink::layerId, mapCellTdc(), mapRobRos(), DTReadOutGeometryLink::robId, DTReadOutGeometryLink::rosId, DTReadOutGeometryLink::sectorId, DTReadOutGeometryLink::slId, DTReadOutGeometryLink::stationId, AlCaHLTBitMon_QueryRunRegistry::string, DTReadOutGeometryLink::tdcId, and DTReadOutGeometryLink::wheelId.

Referenced by fullMap().

                                                                               {
  std::vector<DTReadOutGeometryLink> entryList;
  DTReadOutMapping::const_iterator compIter = compMap.begin();
  DTReadOutMapping::const_iterator compIend = compMap.end();
  while ( compIter != compIend ) entryList.push_back( *compIter++ );

  std::string
  rosMap = "expand_";
  rosMap += compMap.mapRobRos();
  std::string
  tdcMap = "expand_";
  tdcMap += compMap.mapCellTdc();
  DTReadOutMapping* fullMap = new DTReadOutMapping( tdcMap, rosMap );
  int ddu;
  int ros;
  int rch;
  int tdc;
  int tch;
  int whe;
  int sta;
  int sec;
  int rob;
  int qua;
  int lay;
  int cel;
  int mt1;
  int mi1;
  int mt2;
  int mi2;
  int def;
  int wha;
  int sea;
  std::vector<DTReadOutGeometryLink>::const_iterator iter = entryList.begin();
  std::vector<DTReadOutGeometryLink>::const_iterator iend = entryList.end();
  std::vector<DTReadOutGeometryLink>::const_iterator iros = entryList.end();
  std::vector<DTReadOutGeometryLink>::const_iterator irob = entryList.end();
  while ( iter != iend ) {
    const DTReadOutGeometryLink& rosEntry( *iter++ );
    if ( rosEntry.dduId > 0x3fffffff ) continue;
    ddu = rosEntry.dduId;
    ros = rosEntry.rosId;
    whe = rosEntry.wheelId;
    def = rosEntry.stationId;
    sec = rosEntry.sectorId;
    rob = rosEntry.slId;
    mt1 = rosEntry.layerId;
    mi1 = rosEntry.cellId;
    iros = entryList.begin();
    while ( iros != iend ) {
      wha = whe;
      sea = sec;
      const DTReadOutGeometryLink& rchEntry( *iros++ );
      if ( ( rchEntry.dduId != mt1 ) ||
           ( rchEntry.rosId != mi1 ) ) continue;
      rch =  rchEntry.robId;
      if (   rchEntry.wheelId != def   ) wha = rchEntry.wheelId;
      sta =  rchEntry.stationId;
      if (   rchEntry.sectorId != def   ) sea = rchEntry.sectorId;
      rob =  rchEntry.slId;
      mt2 =  rchEntry.layerId;
      mi2 =  rchEntry.cellId;
      irob = entryList.begin();
      while ( irob != iend ) {
        const DTReadOutGeometryLink& robEntry( *irob++ );
        if ( ( robEntry.dduId != mt2 ) ||
             ( robEntry.rosId != mi2 ) ) continue;
        if (   robEntry.robId != rob   ) {
          std::cout << "ROB mismatch " << rob << " "
                                       << robEntry.robId << std::endl;
        }
        tdc =  robEntry.tdcId;
        tch =  robEntry.channelId;
        qua =  robEntry.slId;
        lay =  robEntry.layerId;
        cel =  robEntry.cellId;
        fullMap->insertReadOutGeometryLink( ddu, ros, rch, tdc, tch,
                                                 wha, sta, sea,
                                                 qua, lay, cel );

      }
    }
  }
  return fullMap;
}

const DTReadOutMapping * DTReadOutMapping::fullMap

(

)

const

Expand to full map.

Definition at line 473 of file DTReadOutMapping.cc.

References expandMap(), mapType(), and plain.

Referenced by expandMap().

                                                        {
  if ( mapType() == plain ) return this;
  return expandMap( *this );
}

int DTReadOutMapping::geometryToReadOut	(	int	wheelId,
		int	stationId,
		int	sectorId,
		int	slId,
		int	layerId,
		int	cellId,
		int &	dduId,
		int &	rosId,
		int &	robId,
		int &	tdcId,
		int &	channelId
	)		const

Definition at line 223 of file DTReadOutMapping.cc.

References atomicCache(), cacheMap(), DTReadOutGeometryLink::channelId, DTReadOutGeometryLink::dduId, DTBufferTree< Key, Content >::find(), DTReadOutMappingCache::grBuf, DTReadOutMappingCache::grDDU, DTReadOutMappingCache::grROB, DTReadOutMappingCache::grROS, MainPageGenerator::link, DTReadOutMappingCache::mType, readOutChannelDriftTubeMap, DTReadOutGeometryLink::robId, DTReadOutGeometryLink::rosId, DTReadOutGeometryLink::sectorId, and DTReadOutGeometryLink::wheelId.

Referenced by geometryToReadOut().

                                                                {

  dduId =
  rosId =
  robId =
  tdcId =
  channelId = 0;

  if(!atomicCache().isSet()) {
    cacheMap();
  }

  int defaultValue;
  atomicCache()->mType.find( 0, defaultValue );
  if ( defaultValue ) {

    int loop1 = 0;
    int loop2 = 0;
    int loop3 = 0;
    int loop0 = 0;

    int searchStatus;
    int mapId = 0;
    std::vector<int> const* robMLgr;
    std::vector<int> const* rosMLgr;
    std::vector<int> const* dduMLgr;

    std::vector<int> cellKey;
    cellKey.reserve(6);
    cellKey.push_back(  cellId );
    cellKey.push_back( layerId );
    cellKey.push_back(    slId );
    std::vector<int> stdcKey = cellKey;
    searchStatus = atomicCache()->grROB.find( cellKey.begin(), cellKey.end(), robMLgr );
    if ( searchStatus ) return searchStatus;
    if ( !( robMLgr->size() ) ) return 1;
    std::vector<int>::const_iterator tdc_iter = robMLgr->begin();
    std::vector<int>::const_iterator tdc_iend = robMLgr->end();
    while( tdc_iter != tdc_iend ) {
      loop1++;
      const DTReadOutGeometryLink& ltdc(
            readOutChannelDriftTubeMap[*tdc_iter++] );
      channelId = ltdc.channelId;
          tdcId = ltdc.    tdcId;
      mapId = ltdc.rosId;
      cellKey.clear();
      cellKey.push_back( mapId );
      cellKey.push_back( stationId );
      std::vector<int> srosKey = cellKey;
      searchStatus = atomicCache()->grROS.find( cellKey.begin(), cellKey.end(), rosMLgr );
      if ( searchStatus ) continue;
      if ( !( rosMLgr->size() ) ) continue;
      std::vector<int>::const_iterator ros_iter = rosMLgr->begin();
      std::vector<int>::const_iterator ros_iend = rosMLgr->end();
      while( ros_iter != ros_iend ) {
        loop2++;
        const DTReadOutGeometryLink& lros(
              readOutChannelDriftTubeMap[*ros_iter++] );
        int secCk = lros.sectorId;
        int wheCk = lros. wheelId;
        if ( ( secCk != defaultValue ) && 
             ( secCk != sectorId     ) ) continue;
        if ( ( wheCk != defaultValue ) && 
             ( wheCk !=  wheelId     ) ) continue;
        robId = lros.robId;
        mapId = lros.rosId;
        cellKey.clear();
        cellKey.push_back(    mapId );
        cellKey.push_back(  wheelId );
        cellKey.push_back( sectorId );
        std::vector<int> sdduKey = cellKey;
        searchStatus = atomicCache()->grDDU.find( cellKey.begin(), cellKey.end(), dduMLgr );
        if ( searchStatus ) continue;
        if ( !( dduMLgr->size() ) ) continue;
        if ( searchStatus ) return searchStatus;
        if ( !( dduMLgr->size() ) ) return 1;
        loop0++;
        std::vector<int>::const_iterator ddu_iter = dduMLgr->begin();
        std::vector<int>::const_iterator ddu_iend = dduMLgr->end();
        while( ddu_iter != ddu_iend ) {
          loop3++;
          const DTReadOutGeometryLink& lddu(
                readOutChannelDriftTubeMap[*ddu_iter++] );
          if ( ( ( sectorId == secCk ) || 
                 ( sectorId == lddu.sectorId ) ) &&
               ( (  wheelId == wheCk ) || 
                 (  wheelId == lddu.wheelId ) ) ) {
            rosId = lddu.rosId;
            dduId = lddu.dduId;
            return 0;
          }
        }
      }
    }

    return 1;

  }

  std::vector<int> cellKey;
  cellKey.reserve(6);
  cellKey.push_back(   wheelId );
  cellKey.push_back( stationId );
  cellKey.push_back(  sectorId );
  cellKey.push_back(      slId );
  cellKey.push_back(   layerId );
  cellKey.push_back(    cellId );
  int ientry;
  int searchStatus = atomicCache()->grBuf.find( cellKey.begin(), cellKey.end(), ientry );
  if ( !searchStatus ) {
    const DTReadOutGeometryLink& link( readOutChannelDriftTubeMap[ientry] );
        dduId = link.    dduId;
        rosId = link.    rosId;
        robId = link.    robId;
        tdcId = link.    tdcId;
    channelId = link.channelId;
  }

  return searchStatus;

}

int DTReadOutMapping::geometryToReadOut	(	const DTWireId &	wireId,
		int &	dduId,
		int &	rosId,
		int &	robId,
		int &	tdcId,
		int &	channelId
	)		const

Definition at line 203 of file DTReadOutMapping.cc.

References geometryToReadOut(), DTLayerId::layer(), DTChamberId::sector(), DTChamberId::station(), DTSuperLayerId::superLayer(), DTChamberId::wheel(), and DTWireId::wire().

                                                                {
  return geometryToReadOut( wireId.wheel(),
                  wireId.station(),
                  wireId.sector(),
                  wireId.superLayer(),
                  wireId.layer(),
                  wireId.wire(),
                                       dduId,
                                       rosId,
                                       robId,
                                       tdcId,
                                   channelId);
}

int DTReadOutMapping::insertReadOutGeometryLink	(	int	dduId,
		int	rosId,
		int	robId,
		int	tdcId,
		int	channelId,
		int	wheelId,
		int	stationId,
		int	sectorId,
		int	slId,
		int	layerId,
		int	cellId
	)

insert connection

Definition at line 400 of file DTReadOutMapping.cc.

References atomicCache(), DTReadOutGeometryLink::channelId, edm::ConstRespectingPtr< T >::get(), DTReadOutMappingCache::grBuf, grBuf, DTBufferTree< Key, Content >::insert(), MainPageGenerator::link, readOutChannelDriftTubeMap, DTReadOutMappingCache::rgBuf, rgBuf, and DTReadOutGeometryLink::stationId.

Referenced by expandMap(), and DTReadOutMappingHandler::getNewObjects().

                                                                 {
  DTReadOutGeometryLink link;
  link.    dduId =     dduId;
  link.    rosId =     rosId;
  link.    robId =     robId;
  link.    tdcId =     tdcId;
  link.channelId = channelId;
  link.  wheelId =   wheelId;
  link.stationId = stationId;
  link. sectorId =  sectorId;
  link.     slId =      slId;
  link.  layerId =   layerId;
  link.   cellId =    cellId;

  int ientry = readOutChannelDriftTubeMap.size();
  readOutChannelDriftTubeMap.push_back( link );

  DTBufferTree<int,int>* pgrBuf;
  DTBufferTree<int,int>* prgBuf;

  if(atomicCache().isSet()) {
    pgrBuf = &atomicCache()->grBuf;
    prgBuf = &atomicCache()->rgBuf;
  } else {
    pgrBuf = grBuf.get();
    prgBuf = rgBuf.get();
  }

  std::vector<int> cellKey;
  cellKey.reserve(6);
  cellKey.push_back(   wheelId );
  cellKey.push_back( stationId );
  cellKey.push_back(  sectorId );
  cellKey.push_back(      slId );
  cellKey.push_back(   layerId );
  cellKey.push_back(    cellId );
  int grStatus = pgrBuf->insert( cellKey.begin(), cellKey.end(), ientry );

  std::vector<int> chanKey;
  chanKey.reserve(5);
  chanKey.push_back(     dduId );
  chanKey.push_back(     rosId );
  chanKey.push_back(     robId );
  chanKey.push_back(     tdcId );
  chanKey.push_back( channelId );
  int rgStatus = prgBuf->insert( chanKey.begin(), chanKey.end(), ientry );

  if ( grStatus || rgStatus ) return 1;
  else                        return 0;

}

const std::string & DTReadOutMapping::mapCellTdc

(

)

const

access parent maps identifiers

Definition at line 370 of file DTReadOutMapping.cc.

References cellMapVersion.

Referenced by expandMap().

                                              {
  return cellMapVersion;
}

std::string & DTReadOutMapping::mapCellTdc

(

)

Definition at line 375 of file DTReadOutMapping.cc.

References cellMapVersion.

                                        {
  return cellMapVersion;
}

std::string DTReadOutMapping::mapNameGR ( ) const

private

Definition at line 566 of file DTReadOutMapping.cc.

References cellMapVersion, mergeVDriftHistosByStation::name, and robMapVersion.

                                            {
  std::stringstream name;
  name << cellMapVersion << "_" << robMapVersion << "_map_GR" << this;
  return name.str();
}

std::string DTReadOutMapping::mapNameRG ( ) const

private

Definition at line 573 of file DTReadOutMapping.cc.

References cellMapVersion, mergeVDriftHistosByStation::name, and robMapVersion.

                                            {
  std::stringstream name;
  name << cellMapVersion << "_" << robMapVersion << "_map_RG" << this;
  return name.str();
}

const std::string & DTReadOutMapping::mapRobRos

(

)

const

Definition at line 381 of file DTReadOutMapping.cc.

References robMapVersion.

Referenced by expandMap().

                                             {
  return robMapVersion;
}

std::string & DTReadOutMapping::mapRobRos

(

)

Definition at line 386 of file DTReadOutMapping.cc.

References robMapVersion.

                                       {
  return robMapVersion;
}

DTReadOutMapping::type DTReadOutMapping::mapType

(

)

const

Definition at line 356 of file DTReadOutMapping.cc.

References atomicCache(), cacheMap(), compact, DTBufferTree< Key, Content >::find(), DTReadOutMappingCache::mType, and plain.

Referenced by fullMap().

                                                     {

  if(!atomicCache().isSet()) {
    cacheMap();
  }

  int defaultValue;
  atomicCache()->mType.find( 0, defaultValue );
  if ( defaultValue ) return compact;
  else                return plain;
}

DTReadOutMapping& DTReadOutMapping::operator= ( DTReadOutMapping const &  )

private

int DTReadOutMapping::readOutToGeometry	(	int	dduId,
		int	rosId,
		int	robId,
		int	tdcId,
		int	channelId,
		DTWireId &	wireId
	)		const

transform identifiers

Operations

Definition at line 81 of file DTReadOutMapping.cc.

References ntuplemaker::status.

                                                                  {

  int   wheelId;
  int stationId;
  int  sectorId;
  int      slId;
  int   layerId;
  int    cellId;

  int status = readOutToGeometry(      dduId,
                                       rosId,
                                       robId,
                                       tdcId,
                                   channelId,
                                     wheelId,
                                   stationId,
                                    sectorId,
                                        slId,
                                     layerId,
                                      cellId );

  wireId = DTWireId( wheelId, stationId, sectorId, slId, layerId, cellId );
  return status;

}

int DTReadOutMapping::readOutToGeometry	(	int	dduId,
		int	rosId,
		int	robId,
		int	tdcId,
		int	channelId,
		int &	wheelId,
		int &	stationId,
		int &	sectorId,
		int &	slId,
		int &	layerId,
		int &	cellId
	)		const

Definition at line 113 of file DTReadOutMapping.cc.

References atomicCache(), cacheMap(), DTBufferTree< Key, Content >::find(), MainPageGenerator::link, DTReadOutMappingCache::mType, readOutChannelDriftTubeMap, DTReadOutMappingCache::rgBuf, DTReadOutMappingCache::rgDDU, DTReadOutMappingCache::rgROB, DTReadOutMappingCache::rgROS, and DTReadOutGeometryLink::stationId.

                                                                {

  wheelId   =
  stationId =
  sectorId  =
  slId      =
  layerId   =
  cellId    = 0;

  if(!atomicCache().isSet()) {
    cacheMap();
  }

  int defaultValue;
  atomicCache()->mType.find( 0, defaultValue );
  if ( defaultValue ) {

    int searchStatus;
    int ientry;

    std::vector<int> dduKey;
    dduKey.reserve( 5 );
    dduKey.push_back( dduId );
    dduKey.push_back( rosId );
    searchStatus = atomicCache()->rgDDU.find( dduKey.begin(), dduKey.end(), ientry );
    if ( searchStatus ) return searchStatus;
    const DTReadOutGeometryLink& lros( readOutChannelDriftTubeMap[ientry] );
    wheelId = lros.  wheelId;
    sectorId = lros. sectorId;

    std::vector<int> rosKey;
    rosKey.reserve( 5 );
    rosKey.push_back( lros. cellId );
    rosKey.push_back( robId );
    searchStatus = atomicCache()->rgROS.find( rosKey.begin(), rosKey.end(), ientry );
    if ( searchStatus ) return searchStatus;
    const DTReadOutGeometryLink& lrob( readOutChannelDriftTubeMap[ientry] );
    if ( lrob.  wheelId != defaultValue )  wheelId = lrob.  wheelId;
    stationId = lrob.stationId;
    if ( lrob. sectorId != defaultValue ) sectorId = lrob. sectorId;

    std::vector<int> robKey;
    robKey.reserve( 5 );
    robKey.push_back( lrob. cellId );
    robKey.push_back(     tdcId );
    robKey.push_back( channelId );
    searchStatus = atomicCache()->rgROB.find( robKey.begin(), robKey.end(), ientry );
    if ( searchStatus ) return searchStatus;
    const DTReadOutGeometryLink& ltdc( readOutChannelDriftTubeMap[ientry] );
         slId = ltdc.     slId;
      layerId = ltdc.  layerId;
       cellId = ltdc.   cellId;
    return 0;

  }

  std::vector<int> chanKey;
  chanKey.reserve(5);
  chanKey.push_back(     dduId );
  chanKey.push_back(     rosId );
  chanKey.push_back(     robId );
  chanKey.push_back(     tdcId );
  chanKey.push_back( channelId );
  int ientry;
  int searchStatus = atomicCache()->rgBuf.find( chanKey.begin(), chanKey.end(), ientry );
  if ( !searchStatus ) {
    const DTReadOutGeometryLink& link( readOutChannelDriftTubeMap[ientry] );
      wheelId = link.  wheelId;
    stationId = link.stationId;
     sectorId = link. sectorId;
         slId = link.     slId;
      layerId = link.  layerId;
       cellId = link.   cellId;
  }

  return searchStatus;

}

template<class Archive >

void DTReadOutMapping::serialize ( Archive &  ar, const unsigned int  version  )

private

Friends And Related Function Documentation

friend class boost::serialization::access

friend

Definition at line 182 of file DTReadOutMapping.h.

template<typename CondSerializationT , typename Enabled >

friend struct cond::serialization::access

friend

Definition at line 182 of file DTReadOutMapping.h.

Member Data Documentation

edm::AtomicPtrCache<DTReadOutMappingCache> DTReadOutMapping::atomicCache_

private

Definition at line 171 of file DTReadOutMapping.h.

Referenced by atomicCache().

std::string DTReadOutMapping::cellMapVersion

private

Definition at line 166 of file DTReadOutMapping.h.

Referenced by mapCellTdc(), mapNameGR(), and mapNameRG().

edm::ConstRespectingPtr<DTBufferTree<int,int> > DTReadOutMapping::grBuf

private

Definition at line 173 of file DTReadOutMapping.h.

Referenced by clear(), and insertReadOutGeometryLink().

std::vector<DTReadOutGeometryLink> DTReadOutMapping::readOutChannelDriftTubeMap

private

Definition at line 169 of file DTReadOutMapping.h.

Referenced by begin(), cacheMap(), clear(), DTReadOutMapping(), end(), geometryToReadOut(), insertReadOutGeometryLink(), and readOutToGeometry().

edm::ConstRespectingPtr<DTBufferTree<int,int> > DTReadOutMapping::rgBuf

private

Definition at line 172 of file DTReadOutMapping.h.

Referenced by clear(), and insertReadOutGeometryLink().

std::string DTReadOutMapping::robMapVersion

private

Definition at line 167 of file DTReadOutMapping.h.

Referenced by mapNameGR(), mapNameRG(), and mapRobRos().