CMSSW Reference Manual

DTTFFEDReader::DTTFFEDReader ( const edm::ParameterSet & pset )

Constructor.

Definition at line 30 of file DTTFFEDReader.cc.

References DTTFInputTag, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), and verbose_.

00030                                                         {
00031 
00032   produces<L1MuDTChambPhContainer>();
00033   produces<L1MuDTChambThContainer>();
00034   produces<L1MuDTTrackContainer>("DATA");
00035 
00036   DTTFInputTag = pset.getParameter<edm::InputTag>("DTTF_FED_Source");
00037 
00038   verbose_ =  pset.getUntrackedParameter<bool>("verbose",false);
00039 
00040 }

DTTFFEDReader::~DTTFFEDReader ( ) [virtual]

Destructor.

Definition at line 42 of file DTTFFEDReader.cc.

00042 {}

void DTTFFEDReader::analyse ( edm::Event & e ) [private]

Definition at line 83 of file DTTFFEDReader.cc.

References clear(), match(), and process().

Referenced by fillRawData().

00083                                        {
00084   clear();
00085   process(e);
00086   match();
00087   return;
00088 }

int DTTFFEDReader::bxNr ( int channel ) [private]

Definition at line 441 of file DTTFFEDReader.cc.

Referenced by process().

00441                                     {
00442 
00443   int myChannel = channel;
00444 
00445   if (myChannel > 127) myChannel -= 2;
00446 
00447   if (myChannel < 0 || myChannel > 251 ){ return -999; }
00448 
00449   int myBx = 1-(myChannel%3);
00450 
00451   return myBx;
00452 }

void DTTFFEDReader::calcCRC	(	long	myD1,
		long	myD2,
		int &	myC
	)			`[private]`

Definition at line 478 of file DTTFFEDReader.cc.

References funct::C, funct::D, and i.

Referenced by process().

00478                                                          {
00479 
00480   int myCRC[16],D[64],C[16];
00481 
00482   for( int i=0; i < 32; i++ ){ D[i]=(myD2>>i)&0x1; }
00483   for( int i=0; i < 32; i++ ){ D[i+32]=(myD1>>i)&0x1; }
00484   for( int i=0; i < 16; i++ ){ C[i]=(myC>>i)&0x1; }
00485 
00486   myCRC[0] = ( D[63] + D[62] + D[61] + D[60] + D[55] + D[54] +
00487                D[53] + D[52] + D[51] + D[50] + D[49] + D[48] +
00488                D[47] + D[46] + D[45] + D[43] + D[41] + D[40] +
00489                D[39] + D[38] + D[37] + D[36] + D[35] + D[34] +
00490                D[33] + D[32] + D[31] + D[30] + D[27] + D[26] +
00491                D[25] + D[24] + D[23] + D[22] + D[21] + D[20] +
00492                D[19] + D[18] + D[17] + D[16] + D[15] + D[13] +
00493                D[12] + D[11] + D[10] + D[9]  + D[8]  + D[7]  +
00494                D[6]  + D[5]  + D[4]  + D[3]  + D[2]  + D[1]  +
00495                D[0]  + C[0]  + C[1]  + C[2]  + C[3]  + C[4]  +
00496                C[5]  + C[6]  + C[7]  + C[12] + C[13] + C[14] +
00497                C[15] )%2;
00498 
00499   myCRC[1] = ( D[63] + D[62] + D[61] + D[56] + D[55] + D[54] +
00500                D[53] + D[52] + D[51] + D[50] + D[49] + D[48] +
00501                D[47] + D[46] + D[44] + D[42] + D[41] + D[40] +
00502                D[39] + D[38] + D[37] + D[36] + D[35] + D[34] +
00503                D[33] + D[32] + D[31] + D[28] + D[27] + D[26] +
00504                D[25] + D[24] + D[23] + D[22] + D[21] + D[20] +
00505                D[19] + D[18] + D[17] + D[16] + D[14] + D[13] +
00506                D[12] + D[11] + D[10] + D[9]  + D[8]  + D[7]  +
00507                D[6]  + D[5]  + D[4]  + D[3]  + D[2]  + D[1]  +
00508                C[0]  + C[1]  + C[2]  + C[3]  + C[4]  + C[5]  +
00509                C[6]  + C[7]  + C[8]  + C[13] + C[14] + C[15] )%2;
00510 
00511   myCRC[2] = ( D[61] + D[60] + D[57] + D[56] + D[46] + D[42] +
00512                D[31] + D[30] + D[29] + D[28] + D[16] + D[14] +
00513                D[1]  + D[0]  + C[8]  + C[9]  + C[12] + C[13] )%2;
00514 
00515   myCRC[3] = ( D[62] + D[61] + D[58] + D[57] + D[47] + D[43] +
00516                D[32] + D[31] + D[30] + D[29] + D[17] + D[15] +
00517                D[2]  + D[1]  + C[9]  + C[10] + C[13] + C[14] )%2;
00518 
00519   myCRC[4] = ( D[63] + D[62] + D[59] + D[58] + D[48] + D[44] +
00520                D[33] + D[32] + D[31] + D[30] + D[18] + D[16] + 
00521                D[3]  + D[2]  + C[0]  + C[10] + C[11] + C[14] +
00522                C[15] )%2;
00523 
00524   myCRC[5] = ( D[63] + D[60] + D[59] + D[49] + D[45] + D[34] +
00525                D[33] + D[32] + D[31] + D[19] + D[17] + D[4]  +
00526                D[3]  + C[1]  + C[11] + C[12] + C[15] )%2;
00527 
00528   myCRC[6] = ( D[61] + D[60] + D[50] + D[46] + D[35] + D[34] +
00529                D[33] + D[32] + D[20] + D[18] + D[5]  + D[4]  +
00530                C[2]  + C[12] + C[13] )%2;
00531 
00532   myCRC[7] = ( D[62] + D[61] + D[51] + D[47] + D[36] + D[35] +
00533                D[34] + D[33] + D[21] + D[19] + D[6]  + D[5]  +
00534                C[3]  + C[13] + C[14] )%2;
00535 
00536   myCRC[8] = ( D[63] + D[62] + D[52] + D[48] + D[37] + D[36] +
00537                D[35] + D[34] + D[22] + D[20] + D[7]  + D[6]  +
00538                C[0]  + C[4]  + C[14] + C[15] )%2;
00539 
00540   myCRC[9] = ( D[63] + D[53] + D[49] + D[38] + D[37] + D[36] +
00541                D[35] + D[23] + D[21] + D[8]  + D[7]  + C[1]  +
00542                C[5]  + C[15] )%2;
00543 
00544   myCRC[10] = ( D[54] + D[50] + D[39] + D[38] + D[37] + D[36] + 
00545                 D[24] + D[22] + D[9]  + D[8]  + C[2]  + C[6] )%2;
00546 
00547   myCRC[11] = ( D[55] + D[51] + D[40] + D[39] + D[38] + D[37] +
00548                 D[25] + D[23] + D[10] + D[9]  + C[3]  + C[7] )%2;
00549 
00550   myCRC[12] = ( D[56] + D[52] + D[41] + D[40] + D[39] + D[38] +
00551                 D[26] + D[24] + D[11] + D[10] + C[4]  + C[8] )%2;
00552 
00553   myCRC[13] = ( D[57] + D[53] + D[42] + D[41] + D[40] + D[39] +
00554                 D[27] + D[25] + D[12] + D[11] + C[5]  + C[9] )%2;
00555 
00556   myCRC[14] = ( D[58] + D[54] + D[43] + D[42] + D[41] + D[40] +
00557                 D[28] + D[26] + D[13] + D[12] + C[6]  + C[10] )%2;
00558 
00559   myCRC[15] = ( D[63] + D[62] + D[61] + D[60] + D[59] + D[54] +
00560                 D[53] + D[52] + D[51] + D[50] + D[49] + D[48] + 
00561                 D[47] + D[46] + D[45] + D[44] + D[42] + D[40] +
00562                 D[39] + D[38] + D[37] + D[36] + D[35] + D[34] + 
00563                 D[33] + D[32] + D[31] + D[30] + D[29] + D[26] +
00564                 D[25] + D[24] + D[23] + D[22] + D[21] + D[20] + 
00565                 D[19] + D[18] + D[17] + D[16] + D[15] + D[14] +
00566                 D[12] + D[11] + D[10] + D[9]  + D[8]  + D[7]  + 
00567                 D[6]  + D[5]  + D[4]  + D[3]  + D[2]  + D[1]  +
00568                 D[0]  + C[0]  + C[1]  + C[2]  + C[3]  + C[4]  + 
00569                 C[5]  + C[6]  + C[11] + C[12] + C[13] + C[14] +
00570                 C[15] )%2;
00571 
00572   int tempC = 0x0;  
00573   for(int i=0; i<16 ; i++){ tempC = tempC + (myCRC[i]<<i); }
00574   myC = tempC ;
00575   return;
00576 }

int DTTFFEDReader::channel	(	int	wheel,
		int	sector,
		int	bx
	)			`[private]`

Definition at line 421 of file DTTFFEDReader.cc.

References funct::abs().

00421                                                           {
00422 
00423   // wheel  :  -3 -2 -1 +1 +2 +3 <=> PHTF's : N2, N1, N0, P0, P1, P2
00424   //                           0 <=> ETTF  
00425   // sector :  0 -> 11
00426   // bx     : -1 -> +1
00427 
00428   int myChannel = 255;
00429 
00430   if ( abs(bx) > 1)               { return myChannel; }
00431   if ( sector < 0 || sector > 11) { return myChannel; }
00432   if ( abs(wheel) > 3)            { return myChannel; }
00433 
00434   myChannel = sector*21 + wheel*3 - bx + 10 ; 
00435 
00436   if (myChannel > 125) myChannel += 2;
00437 
00438   return myChannel;
00439 }

void DTTFFEDReader::clear ( void ) [private]

Definition at line 402 of file DTTFFEDReader.cc.

References dtTracks, efTrack, etTrack, i, j, k, edm::es::l(), phiSegments, and theSegments.

Referenced by analyse().

00402                           {
00403   phiSegments.clear();
00404   theSegments.clear();
00405   dtTracks.clear();
00406 
00407   for(int i=0; i<3;  i++){
00408     for(int j=0; j<12; j++){
00409       for(int k=0; k<6;  k++){
00410         for(int l=0; l<2;  l++){
00411           etTrack[i][j][k][l] = 0;
00412           efTrack[i][j][k][l] = 0;
00413         } 
00414       } 
00415     } 
00416   }
00417 
00418   return;
00419 }

bool DTTFFEDReader::fillRawData	(	edm::Event &	e,
		L1MuDTChambPhContainer::Phi_Container &	phi_data,
		L1MuDTChambThContainer::The_Container &	the_data,
		L1MuDTTrackContainer::TrackContainer &	tra_data
	)

Generate and fill FED raw data for a full event.

Definition at line 66 of file DTTFFEDReader.cc.

References analyse(), k_data(), p_data(), and t_data().

Referenced by produce().

00069                                                                                {
00070 
00071   analyse(e);
00072 
00073   phi_data = p_data();
00074   the_data = t_data();
00075   tra_data = k_data();
00076 
00077   return true;
00078 }

edm::InputTag DTTFFEDReader::getDTTFInputTag ( ) [inline, private]

Definition at line 97 of file DTTFFEDReader.h.

References DTTFInputTag.

Referenced by process().

00097 { return DTTFInputTag; }

const L1MuDTTrackContainer::TrackContainer & DTTFFEDReader::k_data ( ) [private]

Definition at line 398 of file DTTFFEDReader.cc.

References dtTracks.

Referenced by fillRawData().

00398                                                                  {
00399   return dtTracks;
00400 }

void DTTFFEDReader::match ( ) [private]

Definition at line 371 of file DTTFFEDReader.cc.

References dtTracks, efTrack, etTrack, and i.

Referenced by analyse().

00371                           {
00372 
00373   for ( L1MuDTTrackContainer::TrackIterator i  = dtTracks.begin();
00374                                             i != dtTracks.end();
00375                                             i++ ) {
00376     int bxTh     = i->bx()+1;
00377     int sectorTh = i->scNum();
00378     int wheelTh  = i->whNum()+3;
00379     if(wheelTh > 3) wheelTh-=1;
00380     int muonTh   = i->TrkTag();
00381 
00382     i->setEtaPacked(etTrack[bxTh][sectorTh][wheelTh][muonTh]);
00383     i->setFineHaloPacked(efTrack[bxTh][sectorTh][wheelTh][muonTh]);
00384   }
00385 
00386   return;
00387 }

const L1MuDTChambPhContainer::Phi_Container & DTTFFEDReader::p_data ( ) [private]

Definition at line 390 of file DTTFFEDReader.cc.

References phiSegments.

Referenced by fillRawData().

00390                                                                  {
00391   return phiSegments;
00392 }

void DTTFFEDReader::process ( edm::Event & e ) [private]

Definition at line 91 of file DTTFFEDReader.cc.

References funct::abs(), bxNr(), calcCRC(), FEDRawData::data(), data, dtTracks, efTrack, etTrack, edm::Event::getByLabel(), getDTTFInputTag(), TopDecayID::muonID, phi, phiSegments, sector(), FEDRawData::size(), theSegments, verbose_, and wheel().

Referenced by analyse().

00091                                        {
00092 
00093   // Container
00094   vector<long> DTTFWordContainer; 
00095   vector<long>::iterator DTTFiterator;
00096 
00097   // Header constituents
00098   int BOEevTy, DTTFId;
00099 
00100   // DTTF Payload constituents 
00101   long DTTFWord;
00102   int DTTFChan, bitsID;
00103   int addr1[2] = { 3,  3};
00104   int addr2[2] = {15, 15};
00105   int addr3[2] = {15, 15};
00106   int addr4[2] = {15, 15};
00107 
00108   // Trailer constituents
00109   int evtLgth , CRC;
00110 
00111   //--> Header
00112 
00113   edm::Handle<FEDRawDataCollection> data;
00114   e.getByLabel(getDTTFInputTag(),data);
00115   FEDRawData dttfdata = data->FEDData(0x030C);
00116   if ( dttfdata.size() == 0 ) return;
00117 
00118   long* dataWord1 = new long;
00119   long* dataWord2 = new long;
00120   unsigned char* LineFED=dttfdata.data();
00121   *dataWord2=*((long*)LineFED);
00122   LineFED+=4;
00123   *dataWord1=*((long*)LineFED);
00124   int lines  = 1; // already counting header
00125 
00126   BOEevTy = ((*dataWord1)&0xFF000000)>>24; // positions 57 ->64
00127   DTTFId  = ((*dataWord2)&0x000FFF00)>>8;  // positions 9 ->20
00128 
00129   if( (BOEevTy != 0x50) || ( DTTFId != 0x030C) ){
00130     if ( verbose_ ) edm::LogWarning("dttf_unpacker")
00131       << "Not a DTTF header " << hex << *dataWord1;
00132     delete dataWord1;
00133     delete dataWord2;
00134     return;
00135   }
00136 
00137   int newCRC =  0xFFFF;
00138   calcCRC(*dataWord1, *dataWord2, newCRC);  
00139 
00140 
00141   //--> DTTF data 
00142 
00143   LineFED+=4;
00144   *dataWord2=*((long*)LineFED);
00145   LineFED+=4;
00146   *dataWord1=*((long*)LineFED);
00147   int chkEOE = ((*dataWord1)&0xFFF00000)>>20; 
00148   lines++;
00149 
00150   while(chkEOE != 0xA00){
00151 
00152     calcCRC(*dataWord1, *dataWord2, newCRC);
00153 
00154     DTTFWord = *dataWord1;
00155     DTTFWordContainer.push_back(DTTFWord);
00156     DTTFWord = *dataWord2;
00157     DTTFWordContainer.push_back(DTTFWord);
00158 
00159     LineFED+=4;
00160     *dataWord2=*((long*)LineFED);
00161     LineFED+=4;
00162     *dataWord1=*((long*)LineFED);
00163     chkEOE = ((*dataWord1)&0xFFF00000)>>20; 
00164     lines++;
00165 
00166     if(lines > 3026){
00167       if ( verbose_ ) edm::LogWarning("dttf_unpacker")
00168         << "Warning : number of DTTF lines > 3026 "; // 3026 = 1(header) + 3024(max # PHTF-ETTF 64 bits words) + 1(trailer)
00169       delete dataWord1;
00170       delete dataWord2;
00171       return;
00172     }
00173 
00174   } // end while-Data loop
00175 
00176 
00177   //--> Trailer
00178 
00179   evtLgth   = ((*dataWord1)&0x00FFFFFF);     // positions 33 ->56
00180   CRC       = ((*dataWord2)&0xFFFF0000)>>16; // positions 17 ->32
00181 
00182   calcCRC(*dataWord1, (*dataWord2)&0xFFFF, newCRC);
00183   if( newCRC != CRC){
00184     if ( verbose_ ) edm::LogWarning("dttf_unpacker")
00185       << "Calculated CRC " << hex << newCRC << " differs from CRC in trailer " << hex << CRC;
00186     delete dataWord1;
00187     delete dataWord2;
00188     return;
00189   }
00190 
00191   if( lines != evtLgth){
00192     if ( verbose_ ) edm::LogWarning("dttf_unpacker")
00193       << "Number of words read != event length " << dec << lines << " " << evtLgth;
00194     delete dataWord1;
00195     delete dataWord2;
00196     return;
00197   }
00198 
00199 
00200   // --> analyse event    
00201 
00202   for( DTTFiterator =  DTTFWordContainer.begin();
00203        DTTFiterator != DTTFWordContainer.end();
00204        DTTFiterator++ ){
00205 
00206     DTTFChan = ((*DTTFiterator)&0xFF000000)>>24;
00207     DTTFiterator++;
00208     bitsID   = ((*DTTFiterator)&0xF0000000)>>28;
00209 
00210     int bxID     = bxNr(DTTFChan);
00211     if(bxID     == -999) continue;
00212     int wheelID  = wheel(DTTFChan);    
00213     if(wheelID  == -999) continue;
00214     int sectorID = sector(DTTFChan);    
00215     if(sectorID == -999) continue;
00216 
00217     //Input
00218     if(wheelID!=0 && bitsID<=0x9){   
00219 
00220       int wheelPh   = (abs(wheelID)-1)*wheelID/abs(wheelID); 
00221       int stationID = 0;
00222       int     ra    = 0;
00223       int     ba    = 0;
00224       int tsqual    = 0;
00225       int ts2tag    = 0;
00226 
00227       if ( ( bitsID >> 1 ) == 0 ){ stationID = 1;}
00228       if ( ( bitsID >> 1 ) == 1 ){ stationID = 2;}
00229       if ( ( bitsID >> 1 ) == 4 ){ stationID = 3;}
00230       if ( ( bitsID >> 1 ) == 2 ){ stationID = 4;}
00231 
00232       if(stationID != 3){ 
00233           
00234         ts2tag = (bitsID)&0x1;
00235         tsqual = (~(*DTTFiterator)&0x07)-1;
00236         ba     = (~(*DTTFiterator)&0x1FF8)>>3;
00237         if( ba>0x1FF) ba-=0x400;
00238         ra     = (~(*DTTFiterator)&0x1FFE000)>>13;
00239         if( ra>0x7FF) ra-=0x1000;
00240       }   
00241       else{ 
00242 
00243         ts2tag = (bitsID)&0x1;
00244         tsqual = (~(*DTTFiterator)&0x07)-1;
00245         ra     = (~(*DTTFiterator)&0x7FF8)>>3;
00246         if( ra>0x7FF) ra-=0x1000;
00247       }
00248 
00249       if(tsqual!=7 && wheelID!=-1){
00250         phiSegments.push_back(
00251                     L1MuDTChambPhDigi( bxID+ts2tag, wheelPh, sectorID, stationID,
00252                     ra, ba, tsqual, ts2tag, 0) );
00253       }
00254     }
00255     //Input
00256 
00257     //Input
00258     if(wheelID==0 && bitsID<=0x4){
00259    
00260       int wheelTh = bitsID-2;
00261 
00262       int posALL, posBTI[7];
00263 
00264       posALL    =  ~(*DTTFiterator)&0x7F;
00265       posBTI[0] =  ~(*DTTFiterator)&0x01;
00266       posBTI[1] = (~(*DTTFiterator)&0x02)>>1;
00267       posBTI[2] = (~(*DTTFiterator)&0x04)>>2;
00268       posBTI[3] = (~(*DTTFiterator)&0x08)>>3;
00269       posBTI[4] = (~(*DTTFiterator)&0x10)>>4;
00270       posBTI[5] = (~(*DTTFiterator)&0x20)>>5;
00271       posBTI[6] = (~(*DTTFiterator)&0x40)>>6;
00272 
00273       if(posALL){
00274         theSegments.push_back(
00275                     L1MuDTChambThDigi( bxID, wheelTh, sectorID, 1, posBTI) );
00276       }
00277 
00278       posALL    =  ~(*DTTFiterator)&0x3F80;
00279       posBTI[0] = (~(*DTTFiterator)&0x0080)>>7;
00280       posBTI[1] = (~(*DTTFiterator)&0x0100)>>8;
00281       posBTI[2] = (~(*DTTFiterator)&0x0200)>>9;
00282       posBTI[3] = (~(*DTTFiterator)&0x0400)>>10;
00283       posBTI[4] = (~(*DTTFiterator)&0x0800)>>11;
00284       posBTI[5] = (~(*DTTFiterator)&0x1000)>>12;
00285       posBTI[6] = (~(*DTTFiterator)&0x2000)>>13;
00286 
00287       if(posALL){
00288         theSegments.push_back(
00289                     L1MuDTChambThDigi( bxID, wheelTh, sectorID, 2, posBTI) );
00290       }
00291 
00292       posALL    =  ~(*DTTFiterator)&0x1FC000;
00293       posBTI[0] = (~(*DTTFiterator)&0x004000)>>14;
00294       posBTI[1] = (~(*DTTFiterator)&0x008000)>>15;
00295       posBTI[2] = (~(*DTTFiterator)&0x010000)>>16;
00296       posBTI[3] = (~(*DTTFiterator)&0x020000)>>17;
00297       posBTI[4] = (~(*DTTFiterator)&0x040000)>>18;
00298       posBTI[5] = (~(*DTTFiterator)&0x080000)>>19;
00299       posBTI[6] = (~(*DTTFiterator)&0x100000)>>20;
00300 
00301       if(posALL){
00302         theSegments.push_back(
00303                     L1MuDTChambThDigi( bxID, wheelTh, sectorID, 3, posBTI) );
00304       }
00305     }
00306     //Input
00307 
00308     //Addresses
00309     if(wheelID!=0 && bitsID>=0xA && bitsID<=0xB){   
00310 
00311       int candID   = bitsID - 0xA;
00312 
00313       addr4[candID]   = ((*DTTFiterator)&0x0F);
00314       addr3[candID]   = ((*DTTFiterator)&0xF0)>>4;
00315       addr2[candID]   = ((*DTTFiterator)&0xF00)>>8;
00316       addr1[candID]   = ((*DTTFiterator)&0x3000)>>12;
00317     }
00318     //Addresses
00319 
00320     //Output
00321     if(wheelID!=0 && bitsID>=0xC){   
00322 
00323       int muonID = 0;
00324       int     pt = 0;
00325       int     ch = 0;
00326       int    phi = 0;
00327       int   qual = 0;  
00328 
00329       muonID = (bitsID&0x1);
00330       qual   = (~(*DTTFiterator)&0x07);
00331       phi    = ((*DTTFiterator)&0x7F8)>>3;
00332       ch     = (~(*DTTFiterator)&0x800)>>11;
00333       pt     = (~(*DTTFiterator)&0x1F000)>>12;
00334 
00335       if(qual!=0){
00336         dtTracks.push_back(
00337                     L1MuDTTrackCand( 0, phi, 0, pt, ch, 1, 0, qual, bxID, wheelID, sectorID,
00338                     muonID, addr1[muonID], addr2[muonID], addr3[muonID], addr4[muonID] ) );
00339       }
00340     }
00341     //Output
00342 
00343     //Output
00344     if(wheelID==0 && bitsID>=0x8){
00345    
00346       int wheelTh = bitsID&0x7;
00347 
00348       int etaALL;
00349 
00350       etaALL =  ~(*DTTFiterator)&0x007F;
00351       if (etaALL) {
00352         etTrack[bxID+1][sectorID][wheelTh][0] =  ~(*DTTFiterator)&0x003F;
00353         efTrack[bxID+1][sectorID][wheelTh][0] = (~(*DTTFiterator)&0x0040)>>6;
00354       }
00355 
00356       etaALL =  (~(*DTTFiterator)&0x3F80)>>7;
00357       if (etaALL) {
00358         etTrack[bxID+1][sectorID][wheelTh][1]= (~(*DTTFiterator)&0x1F80)>>7;
00359         efTrack[bxID+1][sectorID][wheelTh][1]= (~(*DTTFiterator)&0x2000)>>13;
00360       }
00361     }
00362     //Output
00363 
00364   } // end for-loop container content
00365 
00366   delete dataWord1;
00367   delete dataWord2;
00368   return;
00369 }

void DTTFFEDReader::produce	(	edm::Event &	e,
		const edm::EventSetup &	c
	)			`[virtual]`

Produce digis out of raw data.

Implements edm::EDProducer.

Definition at line 44 of file DTTFFEDReader.cc.

References fillRawData(), and edm::Event::put().

00044                                                                {
00045 
00046   auto_ptr<L1MuDTChambPhContainer> phi_product(new L1MuDTChambPhContainer);
00047   auto_ptr<L1MuDTChambThContainer> the_product(new L1MuDTChambThContainer);
00048   auto_ptr<L1MuDTTrackContainer>   tra_product(new L1MuDTTrackContainer);
00049 
00050   L1MuDTChambPhContainer::Phi_Container phi_data;
00051   L1MuDTChambThContainer::The_Container the_data;
00052   L1MuDTTrackContainer::TrackContainer  tra_data;
00053 
00054   if (!fillRawData(e, phi_data, the_data, tra_data)) return;
00055 
00056   phi_product->setContainer(phi_data);
00057   the_product->setContainer(the_data);
00058   tra_product->setContainer(tra_data);
00059 
00060   e.put(phi_product);
00061   e.put(the_product);
00062   e.put(tra_product,"DATA");
00063 
00064 }

int DTTFFEDReader::sector ( int channel ) [private]

Definition at line 454 of file DTTFFEDReader.cc.

Referenced by process().

00454                                       {
00455 
00456   int myChannel = channel;
00457 
00458   if (myChannel > 127) myChannel -= 2;
00459 
00460   if (myChannel < 0 || myChannel > 251 ){ return -999; }
00461 
00462   return myChannel/21;
00463 }

const L1MuDTChambThContainer::The_Container & DTTFFEDReader::t_data ( ) [private]

Definition at line 394 of file DTTFFEDReader.cc.

References theSegments.

Referenced by fillRawData().

00394                                                                  {
00395   return theSegments;
00396 }

int DTTFFEDReader::wheel ( int channel ) [private]

Definition at line 465 of file DTTFFEDReader.cc.

Referenced by process().

00465                                      {
00466 
00467   int myChannel = channel;
00468 
00469   if (myChannel > 127) myChannel -= 2;
00470 
00471   if (myChannel < 0 || myChannel > 251 ){ return -999; }
00472 
00473   int myWheel = ((myChannel%21)/3)-3;
00474 
00475   return myWheel;
00476 }

edm::InputTag DTTFFEDReader::DTTFInputTag [private]

Definition at line 50 of file DTTFFEDReader.h.

Referenced by DTTFFEDReader(), and getDTTFInputTag().

L1MuDTTrackContainer::TrackContainer DTTFFEDReader::dtTracks [private]

Definition at line 80 of file DTTFFEDReader.h.

Referenced by clear(), k_data(), match(), and process().

unsigned int DTTFFEDReader::efTrack[3][12][6][2] [private]

Definition at line 84 of file DTTFFEDReader.h.

Referenced by clear(), match(), and process().

unsigned int DTTFFEDReader::etTrack[3][12][6][2] [private]

Definition at line 82 of file DTTFFEDReader.h.

Referenced by clear(), match(), and process().

L1MuDTChambPhContainer::Phi_Container DTTFFEDReader::phiSegments [private]

Definition at line 76 of file DTTFFEDReader.h.

Referenced by clear(), p_data(), and process().

L1MuDTChambThContainer::The_Container DTTFFEDReader::theSegments [private]

Definition at line 78 of file DTTFFEDReader.h.

Referenced by clear(), process(), and t_data().

bool DTTFFEDReader::verbose_ [private]

Definition at line 52 of file DTTFFEDReader.h.

Referenced by DTTFFEDReader(), and process().

DTTFFEDReader Class Reference

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation


Public Member Functions
	DTTFFEDReader (const edm::ParameterSet &pset)
	Constructor.
bool	fillRawData (edm::Event &e, L1MuDTChambPhContainer::Phi_Container &phi_data, L1MuDTChambThContainer::The_Container &the_data, L1MuDTTrackContainer::TrackContainer &tra_data)
	Generate and fill FED raw data for a full event.
void	produce (edm::Event &e, const edm::EventSetup &c)
	Produce digis out of raw data.
virtual	~DTTFFEDReader ()
	Destructor.
Private Member Functions
void	analyse (edm::Event &e)
int	bxNr (int channel)
void	calcCRC (long myD1, long myD2, int &myC)
int	channel (int wheel, int sector, int bx)
void	clear ()
edm::InputTag	getDTTFInputTag ()
const L1MuDTTrackContainer::TrackContainer &	k_data ()
void	match ()
const L1MuDTChambPhContainer::Phi_Container &	p_data ()
void	process (edm::Event &e)
int	sector (int channel)
const L1MuDTChambThContainer::The_Container &	t_data ()
int	wheel (int channel)
Private Attributes
edm::InputTag	DTTFInputTag
L1MuDTTrackContainer::TrackContainer	dtTracks
unsigned int	efTrack [3][12][6][2]
unsigned int	etTrack [3][12][6][2]
L1MuDTChambPhContainer::Phi_Container	phiSegments
L1MuDTChambThContainer::The_Container	theSegments
bool	verbose_