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 (const DTWireId &wireId, int &dduId, int &rosId, int &robId, int &tdcId, int &channelId) const
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	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...
std::string &	mapCellTdc ()
const std::string &	mapCellTdc () const
	access parent maps identifiers More...
std::string &	mapRobRos ()
const std::string &	mapRobRos () const
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 > &	atomicCache ()
edm::AtomicPtrCache< DTReadOutMappingCache > const &	atomicCache () const
void	cacheMap () const
	read and store full content More...
	DTReadOutMapping (DTReadOutMapping const &)=delete
std::string	mapNameGR () const
std::string	mapNameRG () const
DTReadOutMapping &	operator= (DTReadOutMapping const &)=delete
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 62 of file DTReadOutMapping.h.

Member Typedef Documentation

const_iterator

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

Access methods to the connections.

Definition at line 130 of file DTReadOutMapping.h.

Member Enumeration Documentation

type

enum DTReadOutMapping::type

Enumerator
plain
compact

Definition at line 73 of file DTReadOutMapping.h.

{ plain, compact };

Constructor & Destructor Documentation

DTReadOutMapping() [1/3]

DTReadOutMapping::DTReadOutMapping

(

)

Constructor

Definition at line 33 of file DTReadOutMapping.cc.

    : cellMapVersion(" "), robMapVersion(" "), rgBuf(new DTBufferTree<int, int>), grBuf(new DTBufferTree<int, int>) {
  readOutChannelDriftTubeMap.reserve(2000);
}

References readOutChannelDriftTubeMap.

Referenced by expandMap().

DTReadOutMapping() [2/3]

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

Definition at line 38 of file DTReadOutMapping.cc.

    : cellMapVersion(cell_map_version),
      robMapVersion(rob_map_version),
      rgBuf(new DTBufferTree<int, int>),
      grBuf(new DTBufferTree<int, int>) {
  readOutChannelDriftTubeMap.reserve(2000);
}

References readOutChannelDriftTubeMap.

~DTReadOutMapping()

DTReadOutMapping::~DTReadOutMapping

(

)

Destructor

Definition at line 62 of file DTReadOutMapping.cc.

{}

DTReadOutMapping() [3/3]

DTReadOutMapping::DTReadOutMapping ( DTReadOutMapping const &  )

privatedelete

Member Function Documentation

atomicCache() [1/2]

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

inlineprivate

Definition at line 142 of file DTReadOutMapping.h.

{ return atomicCache_; }

References atomicCache_.

atomicCache() [2/2]

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

inlineprivate

Definition at line 141 of file DTReadOutMapping.h.

{ return atomicCache_; }

References atomicCache_.

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

begin()

DTReadOutMapping::const_iterator DTReadOutMapping::begin

(

void

)

const

Definition at line 404 of file DTReadOutMapping.cc.

{ return readOutChannelDriftTubeMap.begin(); }

References readOutChannelDriftTubeMap.

Referenced by expandMap().

cacheMap()

void DTReadOutMapping::cacheMap ( ) const

private

read and store full content

Definition at line 511 of file DTReadOutMapping.cc.

                                      {
  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 == nullptr) {
        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 == nullptr) {
        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 = nullptr;
        localCache->grDDU.find(cellKey.begin(), cellKey.end(), dduMLgr);
        if (dduMLgr == nullptr) {
          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;
}

References atomicCache(), crabWrapper::key, MainPageGenerator::link, eostools::move(), readOutChannelDriftTubeMap, DTReadOutGeometryLink::sectorId, edm::AtomicPtrCache< T >::set(), heppy_batch::val, and DTReadOutGeometryLink::wheelId.

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

clear()

void DTReadOutMapping::clear

(

void

)

clear map

Definition at line 333 of file DTReadOutMapping.cc.

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

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

Referenced by BeautifulSoup.Tag::setString().

end()

DTReadOutMapping::const_iterator DTReadOutMapping::end

(

void

)

const

Definition at line 406 of file DTReadOutMapping.cc.

{ return readOutChannelDriftTubeMap.end(); }

References readOutChannelDriftTubeMap.

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

expandMap()

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

staticprivate

Definition at line 416 of file DTReadOutMapping.cc.

                                                                             {
  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;
}

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

Referenced by fullMap().

fullMap()

const DTReadOutMapping * DTReadOutMapping::fullMap

(

)

const

Expand to full map.

Definition at line 408 of file DTReadOutMapping.cc.

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

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

Referenced by expandMap().

geometryToReadOut() [1/2]

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

Definition at line 170 of file DTReadOutMapping.cc.

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

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

geometryToReadOut() [2/2]

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 185 of file DTReadOutMapping.cc.

                                                              {
  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;
}

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, DTReadOutGeometryLink::tdcId, and DTReadOutGeometryLink::wheelId.

Referenced by geometryToReadOut().

insertReadOutGeometryLink()

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 341 of file DTReadOutMapping.cc.

                                                            {
  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;
}

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

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

mapCellTdc() [1/2]

std::string & DTReadOutMapping::mapCellTdc

(

)

Definition at line 327 of file DTReadOutMapping.cc.

{ return cellMapVersion; }

References cellMapVersion.

mapCellTdc() [2/2]

const std::string & DTReadOutMapping::mapCellTdc

(

)

const

access parent maps identifiers

Definition at line 325 of file DTReadOutMapping.cc.

{ return cellMapVersion; }

References cellMapVersion.

Referenced by expandMap().

mapNameGR()

std::string DTReadOutMapping::mapNameGR ( ) const

private

Definition at line 499 of file DTReadOutMapping.cc.

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

References cellMapVersion, Skims_PA_cff::name, and robMapVersion.

mapNameRG()

std::string DTReadOutMapping::mapNameRG ( ) const

private

Definition at line 505 of file DTReadOutMapping.cc.

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

References cellMapVersion, Skims_PA_cff::name, and robMapVersion.

mapRobRos() [1/2]

std::string & DTReadOutMapping::mapRobRos

(

)

Definition at line 331 of file DTReadOutMapping.cc.

{ return robMapVersion; }

References robMapVersion.

mapRobRos() [2/2]

const std::string & DTReadOutMapping::mapRobRos

(

)

const

Definition at line 329 of file DTReadOutMapping.cc.

{ return robMapVersion; }

References robMapVersion.

Referenced by expandMap().

mapType()

DTReadOutMapping::type DTReadOutMapping::mapType

(

)

const

Definition at line 312 of file DTReadOutMapping.cc.

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

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

Referenced by fullMap().

operator=()

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

privatedelete

readOutToGeometry() [1/2]

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

transform identifiers

Operations

Definition at line 69 of file DTReadOutMapping.cc.

                                                                                       {
  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;
}

References mps_update::status.

Referenced by DTBlockedROChannelsTest::fillChamberMap(), DTDataIntegrityTest::readOutToGeometry(), and DTBlockedROChannelsTest::readOutToGeometry().

readOutToGeometry() [2/2]

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 85 of file DTReadOutMapping.cc.

                                                           {
  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;
}

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

serialize()

template<class Archive >

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

private

Friends And Related Function Documentation

boost::serialization::access

friend class boost::serialization::access

friend

Definition at line 161 of file DTReadOutMapping.h.

cond::serialization::access

template<typename CondSerializationT , typename Enabled >

friend struct cond::serialization::access

friend

Definition at line 161 of file DTReadOutMapping.h.

Member Data Documentation

atomicCache_

edm::AtomicPtrCache<DTReadOutMappingCache> DTReadOutMapping::atomicCache_

private

Definition at line 151 of file DTReadOutMapping.h.

Referenced by atomicCache().

cellMapVersion

std::string DTReadOutMapping::cellMapVersion

private

Definition at line 146 of file DTReadOutMapping.h.

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

grBuf

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

private

Definition at line 153 of file DTReadOutMapping.h.

Referenced by clear(), and insertReadOutGeometryLink().

readOutChannelDriftTubeMap

std::vector<DTReadOutGeometryLink> DTReadOutMapping::readOutChannelDriftTubeMap

private

Definition at line 149 of file DTReadOutMapping.h.

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

rgBuf

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

private

Definition at line 152 of file DTReadOutMapping.h.

Referenced by clear(), and insertReadOutGeometryLink().

robMapVersion

std::string DTReadOutMapping::robMapVersion

private

Definition at line 147 of file DTReadOutMapping.h.

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