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