CMS 3D CMS Logo
DTReadOutMapping.cc
Go to the documentation of this file.
1 /*
2  * See header file for a description of this class.
3  *
4  * \author Paolo Ronchese INFN Padova
5  *
6  */
7 
8 //----------------------
9 // This Class' Header --
10 //----------------------
11 #include "CondFormats/DTObjects/interface/DTReadOutMapping.h"
12 
13 //-------------------------------
14 // Collaborating Class Headers --
15 //-------------------------------
16 #include "CondFormats/DTObjects/interface/DTBufferTree.h"
17 #include "CondFormats/DTObjects/interface/DTReadOutMappingCache.h"
18 
19 //---------------
20 // C++ Headers --
21 //---------------
22 #include <iostream>
23 #include <sstream>
24 #include <map>
25 
26 //-------------------
27 // Initializations --
28 //-------------------
29 
30 //----------------
31 // Constructors --
32 //----------------
33 DTReadOutMapping::DTReadOutMapping()
34  : cellMapVersion(" "), robMapVersion(" "), rgBuf(new DTBufferTree<int, int>), grBuf(new DTBufferTree<int, int>) {
35  readOutChannelDriftTubeMap.reserve(2000);
36 }
37 
38 DTReadOutMapping::DTReadOutMapping(const std::string& cell_map_version, const std::string& rob_map_version)
39  : cellMapVersion(cell_map_version),
40  robMapVersion(rob_map_version),
41  rgBuf(new DTBufferTree<int, int>),
42  grBuf(new DTBufferTree<int, int>) {
43  readOutChannelDriftTubeMap.reserve(2000);
44 }
45 
46 DTReadOutGeometryLink::DTReadOutGeometryLink()
47  : dduId(0),
48  rosId(0),
49  robId(0),
50  tdcId(0),
51  channelId(0),
52  wheelId(0),
53  stationId(0),
54  sectorId(0),
55  slId(0),
56  layerId(0),
57  cellId(0) {}
58 
59 //--------------
60 // Destructor --
61 //--------------
62 DTReadOutMapping::~DTReadOutMapping() {}
63 
64 DTReadOutGeometryLink::~DTReadOutGeometryLink() {}
65 
66 //--------------
67 // Operations --
68 //--------------
69 int DTReadOutMapping::readOutToGeometry(
70  int dduId, int rosId, int robId, int tdcId, int channelId, DTWireId& wireId) const {
71  int wheelId;
72  int stationId;
73  int sectorId;
74  int slId;
75  int layerId;
76  int cellId;
77 
78  int status =
79  readOutToGeometry(dduId, rosId, robId, tdcId, channelId, wheelId, stationId, sectorId, slId, layerId, cellId);
80 
81  wireId = DTWireId(wheelId, stationId, sectorId, slId, layerId, cellId);
82  return status;
83 }
84 
85 int DTReadOutMapping::readOutToGeometry(int dduId,
86  int rosId,
87  int robId,
88  int tdcId,
89  int channelId,
90  int& wheelId,
91  int& stationId,
92  int& sectorId,
93  int& slId,
94  int& layerId,
95  int& cellId) const {
96  wheelId = stationId = sectorId = slId = layerId = cellId = 0;
97 
98  if (!atomicCache().isSet()) {
99  cacheMap();
100  }
101 
102  int defaultValue;
103  atomicCache()->mType.find(0, defaultValue);
104  if (defaultValue) {
105  int searchStatus;
106  int ientry;
107 
108  std::vector<int> dduKey;
109  dduKey.reserve(5);
110  dduKey.push_back(dduId);
111  dduKey.push_back(rosId);
112  searchStatus = atomicCache()->rgDDU.find(dduKey.begin(), dduKey.end(), ientry);
113  if (searchStatus)
114  return searchStatus;
115  const DTReadOutGeometryLink& lros(readOutChannelDriftTubeMap[ientry]);
116  wheelId = lros.wheelId;
117  sectorId = lros.sectorId;
118 
119  std::vector<int> rosKey;
120  rosKey.reserve(5);
121  rosKey.push_back(lros.cellId);
122  rosKey.push_back(robId);
123  searchStatus = atomicCache()->rgROS.find(rosKey.begin(), rosKey.end(), ientry);
124  if (searchStatus)
125  return searchStatus;
126  const DTReadOutGeometryLink& lrob(readOutChannelDriftTubeMap[ientry]);
127  if (lrob.wheelId != defaultValue)
128  wheelId = lrob.wheelId;
129  stationId = lrob.stationId;
130  if (lrob.sectorId != defaultValue)
131  sectorId = lrob.sectorId;
132 
133  std::vector<int> robKey;
134  robKey.reserve(5);
135  robKey.push_back(lrob.cellId);
136  robKey.push_back(tdcId);
137  robKey.push_back(channelId);
138  searchStatus = atomicCache()->rgROB.find(robKey.begin(), robKey.end(), ientry);
139  if (searchStatus)
140  return searchStatus;
141  const DTReadOutGeometryLink& ltdc(readOutChannelDriftTubeMap[ientry]);
142  slId = ltdc.slId;
143  layerId = ltdc.layerId;
144  cellId = ltdc.cellId;
145  return 0;
146  }
147 
148  std::vector<int> chanKey;
149  chanKey.reserve(5);
150  chanKey.push_back(dduId);
151  chanKey.push_back(rosId);
152  chanKey.push_back(robId);
153  chanKey.push_back(tdcId);
154  chanKey.push_back(channelId);
155  int ientry;
156  int searchStatus = atomicCache()->rgBuf.find(chanKey.begin(), chanKey.end(), ientry);
157  if (!searchStatus) {
158  const DTReadOutGeometryLink& link(readOutChannelDriftTubeMap[ientry]);
159  wheelId = link.wheelId;
160  stationId = link.stationId;
161  sectorId = link.sectorId;
162  slId = link.slId;
163  layerId = link.layerId;
164  cellId = link.cellId;
165  }
166 
167  return searchStatus;
168 }
169 
170 int DTReadOutMapping::geometryToReadOut(
171  const DTWireId& wireId, int& dduId, int& rosId, int& robId, int& tdcId, int& channelId) const {
172  return geometryToReadOut(wireId.wheel(),
173  wireId.station(),
174  wireId.sector(),
175  wireId.superLayer(),
176  wireId.layer(),
177  wireId.wire(),
178  dduId,
179  rosId,
180  robId,
181  tdcId,
182  channelId);
183 }
184 
185 int DTReadOutMapping::geometryToReadOut(int wheelId,
186  int stationId,
187  int sectorId,
188  int slId,
189  int layerId,
190  int cellId,
191  int& dduId,
192  int& rosId,
193  int& robId,
194  int& tdcId,
195  int& channelId) const {
196  dduId = rosId = robId = tdcId = channelId = 0;
197 
198  if (!atomicCache().isSet()) {
199  cacheMap();
200  }
201 
202  int defaultValue;
203  atomicCache()->mType.find(0, defaultValue);
204  if (defaultValue) {
205  int loop1 = 0;
206  int loop2 = 0;
207  int loop3 = 0;
208  int loop0 = 0;
209 
210  int searchStatus;
211  int mapId = 0;
212  std::vector<int> const* robMLgr;
213  std::vector<int> const* rosMLgr;
214  std::vector<int> const* dduMLgr;
215 
216  std::vector<int> cellKey;
217  cellKey.reserve(6);
218  cellKey.push_back(cellId);
219  cellKey.push_back(layerId);
220  cellKey.push_back(slId);
221  std::vector<int> stdcKey = cellKey;
222  searchStatus = atomicCache()->grROB.find(cellKey.begin(), cellKey.end(), robMLgr);
223  if (searchStatus)
224  return searchStatus;
225  if (!(robMLgr->size()))
226  return 1;
227  std::vector<int>::const_iterator tdc_iter = robMLgr->begin();
228  std::vector<int>::const_iterator tdc_iend = robMLgr->end();
229  while (tdc_iter != tdc_iend) {
230  loop1++;
231  const DTReadOutGeometryLink& ltdc(readOutChannelDriftTubeMap[*tdc_iter++]);
232  channelId = ltdc.channelId;
233  tdcId = ltdc.tdcId;
234  mapId = ltdc.rosId;
235  cellKey.clear();
236  cellKey.push_back(mapId);
237  cellKey.push_back(stationId);
238  std::vector<int> srosKey = cellKey;
239  searchStatus = atomicCache()->grROS.find(cellKey.begin(), cellKey.end(), rosMLgr);
240  if (searchStatus)
241  continue;
242  if (!(rosMLgr->size()))
243  continue;
244  std::vector<int>::const_iterator ros_iter = rosMLgr->begin();
245  std::vector<int>::const_iterator ros_iend = rosMLgr->end();
246  while (ros_iter != ros_iend) {
247  loop2++;
248  const DTReadOutGeometryLink& lros(readOutChannelDriftTubeMap[*ros_iter++]);
249  int secCk = lros.sectorId;
250  int wheCk = lros.wheelId;
251  if ((secCk != defaultValue) && (secCk != sectorId))
252  continue;
253  if ((wheCk != defaultValue) && (wheCk != wheelId))
254  continue;
255  robId = lros.robId;
256  mapId = lros.rosId;
257  cellKey.clear();
258  cellKey.push_back(mapId);
259  cellKey.push_back(wheelId);
260  cellKey.push_back(sectorId);
261  std::vector<int> sdduKey = cellKey;
262  searchStatus = atomicCache()->grDDU.find(cellKey.begin(), cellKey.end(), dduMLgr);
263  if (searchStatus)
264  continue;
265  if (!(dduMLgr->size()))
266  continue;
267  if (searchStatus)
268  return searchStatus;
269  if (!(dduMLgr->size()))
270  return 1;
271  loop0++;
272  std::vector<int>::const_iterator ddu_iter = dduMLgr->begin();
273  std::vector<int>::const_iterator ddu_iend = dduMLgr->end();
274  while (ddu_iter != ddu_iend) {
275  loop3++;
276  const DTReadOutGeometryLink& lddu(readOutChannelDriftTubeMap[*ddu_iter++]);
277  if (((sectorId == secCk) || (sectorId == lddu.sectorId)) &&
278  ((wheelId == wheCk) || (wheelId == lddu.wheelId))) {
279  rosId = lddu.rosId;
280  dduId = lddu.dduId;
281  return 0;
282  }
283  }
284  }
285  }
286 
287  return 1;
288  }
289 
290  std::vector<int> cellKey;
291  cellKey.reserve(6);
292  cellKey.push_back(wheelId);
293  cellKey.push_back(stationId);
294  cellKey.push_back(sectorId);
295  cellKey.push_back(slId);
296  cellKey.push_back(layerId);
297  cellKey.push_back(cellId);
298  int ientry;
299  int searchStatus = atomicCache()->grBuf.find(cellKey.begin(), cellKey.end(), ientry);
300  if (!searchStatus) {
301  const DTReadOutGeometryLink& link(readOutChannelDriftTubeMap[ientry]);
302  dduId = link.dduId;
303  rosId = link.rosId;
304  robId = link.robId;
305  tdcId = link.tdcId;
306  channelId = link.channelId;
307  }
308 
309  return searchStatus;
310 }
311 
312 DTReadOutMapping::type DTReadOutMapping::mapType() const {
313  if (!atomicCache().isSet()) {
314  cacheMap();
315  }
316 
317  int defaultValue;
318  atomicCache()->mType.find(0, defaultValue);
319  if (defaultValue)
320  return compact;
321  else
322  return plain;
323 }
324 
325 const std::string& DTReadOutMapping::mapCellTdc() const { return cellMapVersion; }
326 
327 std::string& DTReadOutMapping::mapCellTdc() { return cellMapVersion; }
328 
329 const std::string& DTReadOutMapping::mapRobRos() const { return robMapVersion; }
330 
331 std::string& DTReadOutMapping::mapRobRos() { return robMapVersion; }
332 
333 void DTReadOutMapping::clear() {
334  atomicCache().reset();
335  rgBuf->clear();
336  grBuf->clear();
337  readOutChannelDriftTubeMap.clear();
338  return;
339 }
340 
341 int DTReadOutMapping::insertReadOutGeometryLink(int dduId,
342  int rosId,
343  int robId,
344  int tdcId,
345  int channelId,
346  int wheelId,
347  int stationId,
348  int sectorId,
349  int slId,
350  int layerId,
351  int cellId) {
352  DTReadOutGeometryLink link;
353  link.dduId = dduId;
354  link.rosId = rosId;
355  link.robId = robId;
356  link.tdcId = tdcId;
357  link.channelId = channelId;
358  link.wheelId = wheelId;
359  link.stationId = stationId;
360  link.sectorId = sectorId;
361  link.slId = slId;
362  link.layerId = layerId;
363  link.cellId = cellId;
364 
365  int ientry = readOutChannelDriftTubeMap.size();
366  readOutChannelDriftTubeMap.push_back(link);
367 
368  DTBufferTree<int, int>* pgrBuf;
369  DTBufferTree<int, int>* prgBuf;
370 
371  if (atomicCache().isSet()) {
372  pgrBuf = &atomicCache()->grBuf;
373  prgBuf = &atomicCache()->rgBuf;
374  } else {
375  pgrBuf = grBuf.get();
376  prgBuf = rgBuf.get();
377  }
378 
379  std::vector<int> cellKey;
380  cellKey.reserve(6);
381  cellKey.push_back(wheelId);
382  cellKey.push_back(stationId);
383  cellKey.push_back(sectorId);
384  cellKey.push_back(slId);
385  cellKey.push_back(layerId);
386  cellKey.push_back(cellId);
387  int grStatus = pgrBuf->insert(cellKey.begin(), cellKey.end(), ientry);
388 
389  std::vector<int> chanKey;
390  chanKey.reserve(5);
391  chanKey.push_back(dduId);
392  chanKey.push_back(rosId);
393  chanKey.push_back(robId);
394  chanKey.push_back(tdcId);
395  chanKey.push_back(channelId);
396  int rgStatus = prgBuf->insert(chanKey.begin(), chanKey.end(), ientry);
397 
398  if (grStatus || rgStatus)
399  return 1;
400  else
401  return 0;
402 }
403 
404 DTReadOutMapping::const_iterator DTReadOutMapping::begin() const { return readOutChannelDriftTubeMap.begin(); }
405 
406 DTReadOutMapping::const_iterator DTReadOutMapping::end() const { return readOutChannelDriftTubeMap.end(); }
407 
408 const DTReadOutMapping* DTReadOutMapping::fullMap() const {
409  if (mapType() == plain)
410  return this;
411  return expandMap(*this);
412 }
413 
414 // The code for this function was copied verbatim from
415 // CondCore/DTPlugins/src/DTCompactMapPluginHandler.c
416 DTReadOutMapping* DTReadOutMapping::expandMap(const DTReadOutMapping& compMap) {
417  std::vector<DTReadOutGeometryLink> entryList;
418  DTReadOutMapping::const_iterator compIter = compMap.begin();
419  DTReadOutMapping::const_iterator compIend = compMap.end();
420  while (compIter != compIend)
421  entryList.push_back(*compIter++);
422 
423  std::string rosMap = "expand_";
424  rosMap += compMap.mapRobRos();
425  std::string tdcMap = "expand_";
426  tdcMap += compMap.mapCellTdc();
427  DTReadOutMapping* fullMap = new DTReadOutMapping(tdcMap, rosMap);
428  int ddu;
429  int ros;
430  int rch;
431  int tdc;
432  int tch;
433  int whe;
434  int sta;
435  int sec;
436  int rob;
437  int qua;
438  int lay;
439  int cel;
440  int mt1;
441  int mi1;
442  int mt2;
443  int mi2;
444  int def;
445  int wha;
446  int sea;
447  std::vector<DTReadOutGeometryLink>::const_iterator iter = entryList.begin();
448  std::vector<DTReadOutGeometryLink>::const_iterator iend = entryList.end();
449  std::vector<DTReadOutGeometryLink>::const_iterator iros = entryList.end();
450  std::vector<DTReadOutGeometryLink>::const_iterator irob = entryList.end();
451  while (iter != iend) {
452  const DTReadOutGeometryLink& rosEntry(*iter++);
453  if (rosEntry.dduId > 0x3fffffff)
454  continue;
455  ddu = rosEntry.dduId;
456  ros = rosEntry.rosId;
457  whe = rosEntry.wheelId;
458  def = rosEntry.stationId;
459  sec = rosEntry.sectorId;
460  rob = rosEntry.slId;
461  mt1 = rosEntry.layerId;
462  mi1 = rosEntry.cellId;
463  iros = entryList.begin();
464  while (iros != iend) {
465  wha = whe;
466  sea = sec;
467  const DTReadOutGeometryLink& rchEntry(*iros++);
468  if ((rchEntry.dduId != mt1) || (rchEntry.rosId != mi1))
469  continue;
470  rch = rchEntry.robId;
471  if (rchEntry.wheelId != def)
472  wha = rchEntry.wheelId;
473  sta = rchEntry.stationId;
474  if (rchEntry.sectorId != def)
475  sea = rchEntry.sectorId;
476  rob = rchEntry.slId;
477  mt2 = rchEntry.layerId;
478  mi2 = rchEntry.cellId;
479  irob = entryList.begin();
480  while (irob != iend) {
481  const DTReadOutGeometryLink& robEntry(*irob++);
482  if ((robEntry.dduId != mt2) || (robEntry.rosId != mi2))
483  continue;
484  if (robEntry.robId != rob) {
485  std::cout << "ROB mismatch " << rob << " " << robEntry.robId << std::endl;
486  }
487  tdc = robEntry.tdcId;
488  tch = robEntry.channelId;
489  qua = robEntry.slId;
490  lay = robEntry.layerId;
491  cel = robEntry.cellId;
492  fullMap->insertReadOutGeometryLink(ddu, ros, rch, tdc, tch, wha, sta, sea, qua, lay, cel);
493  }
494  }
495  }
496  return fullMap;
497 }
498 
499 std::string DTReadOutMapping::mapNameGR() const {
500  std::stringstream name;
501  name << cellMapVersion << "_" << robMapVersion << "_map_GR" << this;
502  return name.str();
503 }
504 
505 std::string DTReadOutMapping::mapNameRG() const {
506  std::stringstream name;
507  name << cellMapVersion << "_" << robMapVersion << "_map_RG" << this;
508  return name.str();
509 }
510 
511 void DTReadOutMapping::cacheMap() const {
512  std::unique_ptr<DTReadOutMappingCache> localCache(new DTReadOutMappingCache);
513 
514  localCache->mType.insert(0, 0);
515 
516  int entryNum = 0;
517  int entryMax = readOutChannelDriftTubeMap.size();
518  std::vector<int> cellKey;
519  cellKey.reserve(6);
520  std::vector<int> chanKey;
521  chanKey.reserve(5);
522  int defaultValue = 0;
523  int key;
524  int val;
525  int rosMapKey = 0;
526  int robMapKey = 0;
527  std::map<int, std::vector<int>*> dduEntries;
528  for (entryNum = 0; entryNum < entryMax; entryNum++) {
529  const DTReadOutGeometryLink& link(readOutChannelDriftTubeMap[entryNum]);
530 
531  key = link.dduId;
532  val = link.stationId;
533  if (key > 0x3fffffff) {
534  if (link.tdcId > 0x3fffffff) {
535  localCache->mType.insert(0, defaultValue = link.tdcId);
536  rosMapKey = key;
537  } else {
538  localCache->mType.insert(0, defaultValue = link.wheelId);
539  robMapKey = key;
540  }
541  }
542 
543  if (defaultValue == 0) {
544  chanKey.clear();
545  chanKey.push_back(link.dduId);
546  chanKey.push_back(link.rosId);
547  chanKey.push_back(link.robId);
548  chanKey.push_back(link.tdcId);
549  chanKey.push_back(link.channelId);
550 
551  localCache->rgBuf.insert(chanKey.begin(), chanKey.end(), entryNum);
552 
553  cellKey.clear();
554  cellKey.push_back(link.wheelId);
555  cellKey.push_back(link.stationId);
556  cellKey.push_back(link.sectorId);
557  cellKey.push_back(link.slId);
558  cellKey.push_back(link.layerId);
559  cellKey.push_back(link.cellId);
560 
561  localCache->grBuf.insert(cellKey.begin(), cellKey.end(), entryNum);
562  }
563 
564  if (key == robMapKey) {
565  chanKey.clear();
566  chanKey.push_back(link.rosId);
567  chanKey.push_back(link.tdcId);
568  chanKey.push_back(link.channelId);
569  localCache->rgROB.insert(chanKey.begin(), chanKey.end(), entryNum);
570 
571  cellKey.clear();
572  cellKey.push_back(link.cellId);
573  cellKey.push_back(link.layerId);
574  cellKey.push_back(link.slId);
575  std::vector<int>* robMLgr;
576  localCache->grROB.find(cellKey.begin(), cellKey.end(), robMLgr);
577  if (robMLgr == nullptr) {
578  std::unique_ptr<std::vector<int> > newVector(new std::vector<int>);
579  robMLgr = newVector.get();
580  localCache->grROB.insert(cellKey.begin(), cellKey.end(), std::move(newVector));
581  }
582  robMLgr->push_back(entryNum);
583  }
584 
585  if (key == rosMapKey) {
586  chanKey.clear();
587  chanKey.push_back(link.rosId);
588  chanKey.push_back(link.robId);
589  localCache->rgROS.insert(chanKey.begin(), chanKey.end(), entryNum);
590 
591  cellKey.clear();
592  cellKey.push_back(link.cellId);
593  cellKey.push_back(link.stationId);
594  std::vector<int>* rosMLgr;
595  localCache->grROS.find(cellKey.begin(), cellKey.end(), rosMLgr);
596  if (rosMLgr == nullptr) {
597  std::unique_ptr<std::vector<int> > newVector(new std::vector<int>);
598  rosMLgr = newVector.get();
599  localCache->grROS.insert(cellKey.begin(), cellKey.end(), std::move(newVector));
600  }
601  rosMLgr->push_back(entryNum);
602  }
603 
604  if ((key < 0x3fffffff) && (val > 0x3fffffff)) {
605  chanKey.clear();
606  chanKey.push_back(link.dduId);
607  chanKey.push_back(link.rosId);
608  localCache->rgDDU.insert(chanKey.begin(), chanKey.end(), entryNum);
609 
610  int mapId = link.cellId;
611  std::vector<int>* dduMLgr;
612  std::map<int, std::vector<int>*>::const_iterator dduEntIter = dduEntries.find(mapId);
613  if (dduEntIter == dduEntries.end())
614  dduEntries.insert(std::pair<int, std::vector<int>*>(mapId, dduMLgr = new std::vector<int>));
615  else
616  dduMLgr = dduEntIter->second;
617  dduMLgr->push_back(entryNum);
618  }
619  }
620 
621  if (defaultValue != 0) {
622  for (entryNum = 0; entryNum < entryMax; entryNum++) {
623  const DTReadOutGeometryLink& link(readOutChannelDriftTubeMap[entryNum]);
624  key = link.dduId;
625  if (key != rosMapKey)
626  continue;
627  int mapId = link.rosId;
628  int whchkId = link.wheelId;
629  int secchkId = link.sectorId;
630 
631  std::vector<int>* dduMLgr;
632  std::map<int, std::vector<int>*>::const_iterator dduEntIter = dduEntries.find(mapId);
633  if (dduEntIter != dduEntries.end())
634  dduMLgr = dduEntIter->second;
635  else
636  continue;
637  std::vector<int>::const_iterator dduIter = dduMLgr->begin();
638  std::vector<int>::const_iterator dduIend = dduMLgr->end();
639  while (dduIter != dduIend) {
640  int ientry = *dduIter++;
641  const DTReadOutGeometryLink& lros(readOutChannelDriftTubeMap[ientry]);
642  int wheelId = whchkId;
643  int sectorId = secchkId;
644  if (wheelId == defaultValue)
645  wheelId = lros.wheelId;
646  if (sectorId == defaultValue)
647  sectorId = lros.sectorId;
648  cellKey.clear();
649  cellKey.push_back(mapId);
650  cellKey.push_back(wheelId);
651  cellKey.push_back(sectorId);
652  std::vector<int>* dduMLgr = nullptr;
653  localCache->grDDU.find(cellKey.begin(), cellKey.end(), dduMLgr);
654  if (dduMLgr == nullptr) {
655  std::unique_ptr<std::vector<int> > newVector(new std::vector<int>);
656  dduMLgr = newVector.get();
657  localCache->grDDU.insert(cellKey.begin(), cellKey.end(), std::move(newVector));
658  }
659  dduMLgr->push_back(ientry);
660  }
661  }
662 
663  std::map<int, std::vector<int>*>::const_iterator dduEntIter = dduEntries.begin();
664  std::map<int, std::vector<int>*>::const_iterator dduEntIend = dduEntries.end();
665  while (dduEntIter != dduEntIend) {
666  const std::pair<int, std::vector<int>*>& dduEntry = *dduEntIter++;
667  delete dduEntry.second;
668  }
669 
670  localCache->rgBuf.clear();
671  localCache->grBuf.clear();
672  }
673 
674  atomicCache().set(std::move(localCache));
675 
676  return;
677 }
DTWireId::wire
int wire() const
Return the wire number.
Definition: DTWireId.h:42
edm::ConstRespectingPtr::get
T const * get() const
Definition: ConstRespectingPtr.h:35
DTReadOutMapping::end
const_iterator end() const
Definition: DTReadOutMapping.cc:406
DTReadOutMapping::begin
const_iterator begin() const
Definition: DTReadOutMapping.cc:404
MainPageGenerator.link
link
Definition: MainPageGenerator.py:271
DTReadOutMappingCache::rgROB
DTBufferTree< int, int > rgROB
Definition: DTReadOutMappingCache.h:17
mps_update.status
status
Definition: mps_update.py:69
DTReadOutMappingCache
Definition: DTReadOutMappingCache.h:13
gather_cfg.cout
cout
Definition: gather_cfg.py:144
DTBufferTree::clear
void clear()
edm::AtomicPtrCache::reset
void reset()
unsets the value and deletes the memory
Definition: AtomicPtrCache.h:137
DTReadOutMapping::cacheMap
void cacheMap() const
read and store full content
Definition: DTReadOutMapping.cc:511
DTReadOutMapping::cellMapVersion
std::string cellMapVersion
Definition: DTReadOutMapping.h:146
DTSuperLayerId::superLayer
int superLayer() const
Return the superlayer number.
Definition: DTSuperLayerId.h:39
DTReadOutMappingCache::rgBuf
DTBufferTree< int, int > rgBuf
Definition: DTReadOutMappingCache.h:16
DTReadOutMappingCache::grDDU
DTBufferTree< int, std::unique_ptr< std::vector< int > > > grDDU
Definition: DTReadOutMappingCache.h:24
DTReadOutMapping::expandMap
static DTReadOutMapping * expandMap(const DTReadOutMapping &compMap)
Definition: DTReadOutMapping.cc:416
DTReadOutMapping::mapNameGR
std::string mapNameGR() const
Definition: DTReadOutMapping.cc:499
edm::AtomicPtrCache::set
bool set(std::unique_ptr< T > iNewValue) const
Definition: AtomicPtrCache.h:127
DTReadOutMapping::type
type
Definition: DTReadOutMapping.h:73
DTReadOutMapping::mapNameRG
std::string mapNameRG() const
Definition: DTReadOutMapping.cc:505
DTReadOutMapping::compact
Definition: DTReadOutMapping.h:73
DTBufferTree::insert
int insert(ElementKey fKey, ElementKey lKey, Content cont)
DTWireId
Definition: DTWireId.h:12
DTReadOutMapping::mapType
type mapType() const
Definition: DTReadOutMapping.cc:312
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
DTBufferTree.h
DTReadOutMappingCache.h
MT2Analyzer.mt2
mt2
Definition: MT2Analyzer.py:251
DTReadOutMapping::geometryToReadOut
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
Definition: DTReadOutMapping.cc:185
DTReadOutMappingCache::grBuf
DTBufferTree< int, int > grBuf
Definition: DTReadOutMappingCache.h:20
createfilelist.int
int
Definition: createfilelist.py:10
DTReadOutMapping::readOutToGeometry
int readOutToGeometry(int dduId, int rosId, int robId, int tdcId, int channelId, DTWireId &wireId) const
transform identifiers
Definition: DTReadOutMapping.cc:69
DTReadOutMappingCache::rgROS
DTBufferTree< int, int > rgROS
Definition: DTReadOutMappingCache.h:18
DTBufferTree
Definition: DTBufferTree.h:42
DTReadOutMappingCache::grROS
DTBufferTree< int, std::unique_ptr< std::vector< int > > > grROS
Definition: DTReadOutMappingCache.h:23
DTReadOutMapping::fullMap
const DTReadOutMapping * fullMap() const
Expand to full map.
Definition: DTReadOutMapping.cc:408
DTReadOutMapping::rgBuf
edm::ConstRespectingPtr< DTBufferTree< int, int > > rgBuf
Definition: DTReadOutMapping.h:152
fileinputsource_cfi.sec
sec
Definition: fileinputsource_cfi.py:94
DTChamberId::sector
int sector() const
Definition: DTChamberId.h:49
heppy_batch.val
val
Definition: heppy_batch.py:351
eostools.move
def move(src, dest)
Definition: eostools.py:511
DTReadOutMappingCache::rgDDU
DTBufferTree< int, int > rgDDU
Definition: DTReadOutMappingCache.h:19
DTReadOutMapping::robMapVersion
std::string robMapVersion
Definition: DTReadOutMapping.h:147
DTReadOutMappingCache::grROB
DTBufferTree< int, std::unique_ptr< std::vector< int > > > grROB
Definition: DTReadOutMappingCache.h:22
Skims_PA_cff.name
name
Definition: Skims_PA_cff.py:17
DTReadOutMapping::atomicCache
edm::AtomicPtrCache< DTReadOutMappingCache > const & atomicCache() const
Definition: DTReadOutMapping.h:141
DTReadOutMapping::mapCellTdc
const std::string & mapCellTdc() const
access parent maps identifiers
Definition: DTReadOutMapping.cc:325
spu::def
int def(FILE *, FILE *, int)
Definition: SherpackUtilities.cc:14
DTReadOutMapping::insertReadOutGeometryLink
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
Definition: DTReadOutMapping.cc:341
DTReadOutMapping::DTReadOutMapping
DTReadOutMapping()
Definition: DTReadOutMapping.cc:33
DTReadOutMapping::const_iterator
std::vector< DTReadOutGeometryLink >::const_iterator const_iterator
Access methods to the connections.
Definition: DTReadOutMapping.h:130
DTBufferTree::find
int find(ElementKey fKey, ElementKey lKey, typename DTBufferTreeTrait< Content >::outputTypeOfConstFind &cont) const
DTLayerId::layer
int layer() const
Return the layer number.
Definition: DTLayerId.h:42
crabWrapper.key
key
Definition: crabWrapper.py:19
DTReadOutMapping::plain
Definition: DTReadOutMapping.h:73
DTReadOutMapping::clear
void clear()
clear map
Definition: DTReadOutMapping.cc:333
DTReadOutMapping::mapRobRos
const std::string & mapRobRos() const
Definition: DTReadOutMapping.cc:329
DTChamberId::wheel
int wheel() const
Return the wheel number.
Definition: DTChamberId.h:39
DTReadOutMapping::readOutChannelDriftTubeMap
std::vector< DTReadOutGeometryLink > readOutChannelDriftTubeMap
Definition: DTReadOutMapping.h:149
DTReadOutMapping.h
DTChamberId::station
int station() const
Return the station number.
Definition: DTChamberId.h:42
DTReadOutMapping::~DTReadOutMapping
~DTReadOutMapping()
Definition: DTReadOutMapping.cc:62
DTReadOutMapping
Definition: DTReadOutMapping.h:62
DTReadOutMapping::grBuf
edm::ConstRespectingPtr< DTBufferTree< int, int > > grBuf
Definition: DTReadOutMapping.h:153
DTReadOutMappingCache::mType
DTBufferTree< int, int > mType
Definition: DTReadOutMappingCache.h:15
Generated for CMSSW Reference Manual by doxygen 1.8.16