CMS 3D CMS Logo

/data/git/CMSSW_5_3_11_patch5/src/EventFilter/DTTFRawToDigi/src/DTTFFEDReader.cc

Go to the documentation of this file.
00001 //-------------------------------------------------
00002 //
00003 //   Class: DTTFFEDReader
00004 //
00005 //   L1 DT Track Finder Raw-to-Digi
00006 //
00007 //
00008 //   $Date: 2009/11/18 13:27:12 $
00009 //   $Revision: 1.16 $
00010 //
00011 //   Author :
00012 //   J. Troconiz  UAM Madrid
00013 //
00014 //--------------------------------------------------
00015 
00016 #include "EventFilter/DTTFRawToDigi/interface/DTTFFEDReader.h"
00017 
00018 #include "DataFormats/Common/interface/Handle.h"
00019 #include "FWCore/Framework/interface/Event.h"
00020 #include "FWCore/MessageLogger/interface/MessageLogger.h"
00021 
00022 #include <DataFormats/FEDRawData/interface/FEDRawData.h>
00023 #include <DataFormats/FEDRawData/interface/FEDRawDataCollection.h>
00024 
00025 #include <iostream>
00026 
00027 using namespace std;
00028 
00029 
00030 DTTFFEDReader::DTTFFEDReader(const edm::ParameterSet& pset) {
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 }
00041 
00042 DTTFFEDReader::~DTTFFEDReader(){}
00043 
00044 void DTTFFEDReader::produce(edm::Event& e, const edm::EventSetup& c) {
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 }
00065 
00066 bool DTTFFEDReader::fillRawData(edm::Event& e,
00067                                 L1MuDTChambPhContainer::Phi_Container& phi_data,
00068                                 L1MuDTChambThContainer::The_Container& the_data,
00069                                 L1MuDTTrackContainer::TrackContainer&  tra_data) {
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 }
00079 
00080 //--------------
00081 // Operations --
00082 //--------------
00083 void DTTFFEDReader::analyse(edm::Event& e) {
00084   clear();
00085   process(e);
00086   match();
00087   return;
00088 }
00089 
00090 // process data
00091 void DTTFFEDReader::process(edm::Event& e) {
00092 
00093   // Container
00094   vector<int> DTTFWordContainer; 
00095   vector<int>::iterator DTTFiterator;
00096 
00097   // Header constituents
00098   int BOEevTy, DTTFId;
00099 
00100   // DTTF Payload constituents 
00101   int 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   int* dataWord1 = new int;
00119   int* dataWord2 = new int;
00120   unsigned char* LineFED=dttfdata.data();
00121   *dataWord2=*((int*)LineFED);
00122   LineFED+=4;
00123   *dataWord1=*((int*)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=*((int*)LineFED);
00145   LineFED+=4;
00146   *dataWord1=*((int*)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=*((int*)LineFED);
00161     LineFED+=4;
00162     *dataWord1=*((int*)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       if ( wheelTh == -2 || wheelTh == -1 || 
00265            ( wheelTh == 0 && (sectorID == 0 || sectorID == 3 || sectorID == 4 || sectorID == 7 || sectorID == 8 || sectorID == 11) ) ) {
00266 
00267         posALL    =  ~(*DTTFiterator)&0x7F;
00268         posBTI[0] =  ~(*DTTFiterator)&0x01;
00269         posBTI[1] = (~(*DTTFiterator)&0x02)>>1;
00270         posBTI[2] = (~(*DTTFiterator)&0x04)>>2;
00271         posBTI[3] = (~(*DTTFiterator)&0x08)>>3;
00272         posBTI[4] = (~(*DTTFiterator)&0x10)>>4;
00273         posBTI[5] = (~(*DTTFiterator)&0x20)>>5;
00274         posBTI[6] = (~(*DTTFiterator)&0x40)>>6;
00275 
00276         if(posALL){
00277           theSegments.push_back(
00278                       L1MuDTChambThDigi( bxID, wheelTh, sectorID, 1, posBTI) );
00279         }
00280 
00281         posALL    =  ~(*DTTFiterator)&0x3F80;
00282         posBTI[0] = (~(*DTTFiterator)&0x0080)>>7;
00283         posBTI[1] = (~(*DTTFiterator)&0x0100)>>8;
00284         posBTI[2] = (~(*DTTFiterator)&0x0200)>>9;
00285         posBTI[3] = (~(*DTTFiterator)&0x0400)>>10;
00286         posBTI[4] = (~(*DTTFiterator)&0x0800)>>11;
00287         posBTI[5] = (~(*DTTFiterator)&0x1000)>>12;
00288         posBTI[6] = (~(*DTTFiterator)&0x2000)>>13;
00289 
00290         if(posALL){
00291           theSegments.push_back(
00292                       L1MuDTChambThDigi( bxID, wheelTh, sectorID, 2, posBTI) );
00293         }
00294 
00295         posALL    =  ~(*DTTFiterator)&0x1FC000;
00296         posBTI[0] = (~(*DTTFiterator)&0x004000)>>14;
00297         posBTI[1] = (~(*DTTFiterator)&0x008000)>>15;
00298         posBTI[2] = (~(*DTTFiterator)&0x010000)>>16;
00299         posBTI[3] = (~(*DTTFiterator)&0x020000)>>17;
00300         posBTI[4] = (~(*DTTFiterator)&0x040000)>>18;
00301         posBTI[5] = (~(*DTTFiterator)&0x080000)>>19;
00302         posBTI[6] = (~(*DTTFiterator)&0x100000)>>20;
00303 
00304         if(posALL){
00305           theSegments.push_back(
00306                       L1MuDTChambThDigi( bxID, wheelTh, sectorID, 3, posBTI) );
00307         }
00308       }
00309 
00310       else {
00311 
00312         posALL    =  ~(*DTTFiterator)&0x7F;
00313         posBTI[6] =  ~(*DTTFiterator)&0x01;
00314         posBTI[5] = (~(*DTTFiterator)&0x02)>>1;
00315         posBTI[4] = (~(*DTTFiterator)&0x04)>>2;
00316         posBTI[3] = (~(*DTTFiterator)&0x08)>>3;
00317         posBTI[2] = (~(*DTTFiterator)&0x10)>>4;
00318         posBTI[1] = (~(*DTTFiterator)&0x20)>>5;
00319         posBTI[0] = (~(*DTTFiterator)&0x40)>>6;
00320 
00321         if(posALL){
00322           theSegments.push_back(
00323                       L1MuDTChambThDigi( bxID, wheelTh, sectorID, 1, posBTI) );
00324         }
00325 
00326         posALL    =  ~(*DTTFiterator)&0x3F80;
00327         posBTI[6] = (~(*DTTFiterator)&0x0080)>>7;
00328         posBTI[5] = (~(*DTTFiterator)&0x0100)>>8;
00329         posBTI[4] = (~(*DTTFiterator)&0x0200)>>9;
00330         posBTI[3] = (~(*DTTFiterator)&0x0400)>>10;
00331         posBTI[2] = (~(*DTTFiterator)&0x0800)>>11;
00332         posBTI[1] = (~(*DTTFiterator)&0x1000)>>12;
00333         posBTI[0] = (~(*DTTFiterator)&0x2000)>>13;
00334 
00335         if(posALL){
00336           theSegments.push_back(
00337                       L1MuDTChambThDigi( bxID, wheelTh, sectorID, 2, posBTI) );
00338         }
00339 
00340         posALL    =  ~(*DTTFiterator)&0x1FC000;
00341         posBTI[6] = (~(*DTTFiterator)&0x004000)>>14;
00342         posBTI[5] = (~(*DTTFiterator)&0x008000)>>15;
00343         posBTI[4] = (~(*DTTFiterator)&0x010000)>>16;
00344         posBTI[3] = (~(*DTTFiterator)&0x020000)>>17;
00345         posBTI[2] = (~(*DTTFiterator)&0x040000)>>18;
00346         posBTI[1] = (~(*DTTFiterator)&0x080000)>>19;
00347         posBTI[0] = (~(*DTTFiterator)&0x100000)>>20;
00348 
00349         if(posALL){
00350           theSegments.push_back(
00351                       L1MuDTChambThDigi( bxID, wheelTh, sectorID, 3, posBTI) );
00352         }
00353       }
00354     }
00355     //Input
00356 
00357     //Addresses
00358     if(wheelID!=0 && bitsID>=0xA && bitsID<=0xB){   
00359 
00360       int candID   = bitsID - 0xA;
00361 
00362       addr4[candID]   = ((*DTTFiterator)&0x0F);
00363       addr3[candID]   = ((*DTTFiterator)&0xF0)>>4;
00364       addr2[candID]   = ((*DTTFiterator)&0xF00)>>8;
00365       addr1[candID]   = ((*DTTFiterator)&0x3000)>>12;
00366     }
00367     //Addresses
00368 
00369     //Output
00370     if(wheelID!=0 && bitsID>=0xC){   
00371 
00372       int muonID = 0;
00373       int     pt = 0;
00374       int     ch = 0;
00375       int    phi = 0;
00376       int   qual = 0;  
00377 
00378       muonID = (bitsID&0x1);
00379       qual   = (~(*DTTFiterator)&0x07);
00380       phi    = ((*DTTFiterator)&0x7F8)>>3;
00381       ch     = (~(*DTTFiterator)&0x800)>>11;
00382       pt     = (~(*DTTFiterator)&0x1F000)>>12;
00383 
00384       if(qual!=0){
00385         dtTracks.push_back(
00386                     L1MuDTTrackCand( 0, phi, 0, pt, ch, 1, 0, qual, bxID, wheelID, sectorID,
00387                     muonID, addr1[muonID], addr2[muonID], addr3[muonID], addr4[muonID] ) );
00388       }
00389     }
00390     //Output
00391 
00392     //Output
00393     if(wheelID==0 && bitsID>=0x8){
00394    
00395       int wheelTh = bitsID&0x7;
00396 
00397       int etaALL;
00398 
00399       etaALL =  ~(*DTTFiterator)&0x007F;
00400       if (etaALL) {
00401         etTrack[bxID+1][sectorID][wheelTh][0] =   (*DTTFiterator)&0x003F;
00402         efTrack[bxID+1][sectorID][wheelTh][0] = (~(*DTTFiterator)&0x0040)>>6;
00403       }
00404 
00405       etaALL =  (~(*DTTFiterator)&0x3F80)>>7;
00406       if (etaALL) {
00407         etTrack[bxID+1][sectorID][wheelTh][1]= ( (*DTTFiterator)&0x1F80)>>7;
00408         efTrack[bxID+1][sectorID][wheelTh][1]= (~(*DTTFiterator)&0x2000)>>13;
00409       }
00410     }
00411     //Output
00412 
00413   } // end for-loop container content
00414 
00415   delete dataWord1;
00416   delete dataWord2;
00417   return;
00418 }
00419 
00420 void DTTFFEDReader::match() {
00421 
00422   for ( L1MuDTTrackContainer::TrackIterator i  = dtTracks.begin();
00423                                             i != dtTracks.end();
00424                                             i++ ) {
00425     int bxTh     = i->bx()+1;
00426     int sectorTh = i->scNum();
00427     int wheelTh  = i->whNum()+3;
00428     if(wheelTh > 3) wheelTh-=1;
00429     int muonTh   = i->TrkTag();
00430 
00431     i->setEtaPacked(etTrack[bxTh][sectorTh][wheelTh][muonTh]);
00432     i->setFineHaloPacked(efTrack[bxTh][sectorTh][wheelTh][muonTh]);
00433   }
00434 
00435   return;
00436 }
00437 
00438 // access data
00439 const L1MuDTChambPhContainer::Phi_Container& DTTFFEDReader::p_data() {
00440   return phiSegments;
00441 }
00442 
00443 const L1MuDTChambThContainer::The_Container& DTTFFEDReader::t_data() {
00444   return theSegments;
00445 }
00446 
00447 const L1MuDTTrackContainer::TrackContainer&  DTTFFEDReader::k_data() {
00448   return dtTracks;
00449 }
00450 
00451 void DTTFFEDReader::clear() {
00452   phiSegments.clear();
00453   theSegments.clear();
00454   dtTracks.clear();
00455 
00456   for(int i=0; i<3;  i++){
00457     for(int j=0; j<12; j++){
00458       for(int k=0; k<6;  k++){
00459         for(int l=0; l<2;  l++){
00460           etTrack[i][j][k][l] = 0;
00461           efTrack[i][j][k][l] = 0;
00462         } 
00463       } 
00464     } 
00465   }
00466 
00467   return;
00468 }
00469 
00470 int DTTFFEDReader::channel( int wheel, int sector,  int bx ){
00471 
00472   // wheel  :  -3 -2 -1 +1 +2 +3 <=> PHTF's : N2, N1, N0, P0, P1, P2
00473   //                           0 <=> ETTF  
00474   // sector :  0 -> 11
00475   // bx     : -1 -> +1
00476 
00477   int myChannel = 255;
00478 
00479   if ( abs(bx) > 1)               { return myChannel; }
00480   if ( sector < 0 || sector > 11) { return myChannel; }
00481   if ( abs(wheel) > 3)            { return myChannel; }
00482 
00483   myChannel = sector*21 + wheel*3 - bx + 10 ; 
00484 
00485   if (myChannel > 125) myChannel += 2;
00486 
00487   return myChannel;
00488 }
00489 
00490 int DTTFFEDReader::bxNr( int channel ){
00491 
00492   int myChannel = channel;
00493 
00494   if (myChannel > 127) myChannel -= 2;
00495 
00496   if (myChannel < 0 || myChannel > 251 ){ return -999; }
00497 
00498   int myBx = 1-(myChannel%3);
00499 
00500   return myBx;
00501 }
00502 
00503 int DTTFFEDReader::sector( int channel ){
00504 
00505   int myChannel = channel;
00506 
00507   if (myChannel > 127) myChannel -= 2;
00508 
00509   if (myChannel < 0 || myChannel > 251 ){ return -999; }
00510 
00511   return myChannel/21;
00512 }
00513 
00514 int DTTFFEDReader::wheel( int channel ){
00515 
00516   int myChannel = channel;
00517 
00518   if (myChannel > 127) myChannel -= 2;
00519 
00520   if (myChannel < 0 || myChannel > 251 ){ return -999; }
00521 
00522   int myWheel = ((myChannel%21)/3)-3;
00523 
00524   return myWheel;
00525 }
00526 
00527 void DTTFFEDReader::calcCRC(int myD1, int myD2, int &myC){
00528 
00529   int myCRC[16],D[64],C[16];
00530 
00531   for( int i=0; i < 32; i++ ){ D[i]=(myD2>>i)&0x1; }
00532   for( int i=0; i < 32; i++ ){ D[i+32]=(myD1>>i)&0x1; }
00533   for( int i=0; i < 16; i++ ){ C[i]=(myC>>i)&0x1; }
00534 
00535   myCRC[0] = ( D[63] + D[62] + D[61] + D[60] + D[55] + D[54] +
00536                D[53] + D[52] + D[51] + D[50] + D[49] + D[48] +
00537                D[47] + D[46] + D[45] + D[43] + D[41] + D[40] +
00538                D[39] + D[38] + D[37] + D[36] + D[35] + D[34] +
00539                D[33] + D[32] + D[31] + D[30] + D[27] + D[26] +
00540                D[25] + D[24] + D[23] + D[22] + D[21] + D[20] +
00541                D[19] + D[18] + D[17] + D[16] + D[15] + D[13] +
00542                D[12] + D[11] + D[10] + D[9]  + D[8]  + D[7]  +
00543                D[6]  + D[5]  + D[4]  + D[3]  + D[2]  + D[1]  +
00544                D[0]  + C[0]  + C[1]  + C[2]  + C[3]  + C[4]  +
00545                C[5]  + C[6]  + C[7]  + C[12] + C[13] + C[14] +
00546                C[15] )%2;
00547 
00548   myCRC[1] = ( D[63] + D[62] + D[61] + D[56] + D[55] + D[54] +
00549                D[53] + D[52] + D[51] + D[50] + D[49] + D[48] +
00550                D[47] + D[46] + D[44] + D[42] + D[41] + D[40] +
00551                D[39] + D[38] + D[37] + D[36] + D[35] + D[34] +
00552                D[33] + D[32] + D[31] + D[28] + D[27] + D[26] +
00553                D[25] + D[24] + D[23] + D[22] + D[21] + D[20] +
00554                D[19] + D[18] + D[17] + D[16] + D[14] + D[13] +
00555                D[12] + D[11] + D[10] + D[9]  + D[8]  + D[7]  +
00556                D[6]  + D[5]  + D[4]  + D[3]  + D[2]  + D[1]  +
00557                C[0]  + C[1]  + C[2]  + C[3]  + C[4]  + C[5]  +
00558                C[6]  + C[7]  + C[8]  + C[13] + C[14] + C[15] )%2;
00559 
00560   myCRC[2] = ( D[61] + D[60] + D[57] + D[56] + D[46] + D[42] +
00561                D[31] + D[30] + D[29] + D[28] + D[16] + D[14] +
00562                D[1]  + D[0]  + C[8]  + C[9]  + C[12] + C[13] )%2;
00563 
00564   myCRC[3] = ( D[62] + D[61] + D[58] + D[57] + D[47] + D[43] +
00565                D[32] + D[31] + D[30] + D[29] + D[17] + D[15] +
00566                D[2]  + D[1]  + C[9]  + C[10] + C[13] + C[14] )%2;
00567 
00568   myCRC[4] = ( D[63] + D[62] + D[59] + D[58] + D[48] + D[44] +
00569                D[33] + D[32] + D[31] + D[30] + D[18] + D[16] + 
00570                D[3]  + D[2]  + C[0]  + C[10] + C[11] + C[14] +
00571                C[15] )%2;
00572 
00573   myCRC[5] = ( D[63] + D[60] + D[59] + D[49] + D[45] + D[34] +
00574                D[33] + D[32] + D[31] + D[19] + D[17] + D[4]  +
00575                D[3]  + C[1]  + C[11] + C[12] + C[15] )%2;
00576 
00577   myCRC[6] = ( D[61] + D[60] + D[50] + D[46] + D[35] + D[34] +
00578                D[33] + D[32] + D[20] + D[18] + D[5]  + D[4]  +
00579                C[2]  + C[12] + C[13] )%2;
00580 
00581   myCRC[7] = ( D[62] + D[61] + D[51] + D[47] + D[36] + D[35] +
00582                D[34] + D[33] + D[21] + D[19] + D[6]  + D[5]  +
00583                C[3]  + C[13] + C[14] )%2;
00584 
00585   myCRC[8] = ( D[63] + D[62] + D[52] + D[48] + D[37] + D[36] +
00586                D[35] + D[34] + D[22] + D[20] + D[7]  + D[6]  +
00587                C[0]  + C[4]  + C[14] + C[15] )%2;
00588 
00589   myCRC[9] = ( D[63] + D[53] + D[49] + D[38] + D[37] + D[36] +
00590                D[35] + D[23] + D[21] + D[8]  + D[7]  + C[1]  +
00591                C[5]  + C[15] )%2;
00592 
00593   myCRC[10] = ( D[54] + D[50] + D[39] + D[38] + D[37] + D[36] + 
00594                 D[24] + D[22] + D[9]  + D[8]  + C[2]  + C[6] )%2;
00595 
00596   myCRC[11] = ( D[55] + D[51] + D[40] + D[39] + D[38] + D[37] +
00597                 D[25] + D[23] + D[10] + D[9]  + C[3]  + C[7] )%2;
00598 
00599   myCRC[12] = ( D[56] + D[52] + D[41] + D[40] + D[39] + D[38] +
00600                 D[26] + D[24] + D[11] + D[10] + C[4]  + C[8] )%2;
00601 
00602   myCRC[13] = ( D[57] + D[53] + D[42] + D[41] + D[40] + D[39] +
00603                 D[27] + D[25] + D[12] + D[11] + C[5]  + C[9] )%2;
00604 
00605   myCRC[14] = ( D[58] + D[54] + D[43] + D[42] + D[41] + D[40] +
00606                 D[28] + D[26] + D[13] + D[12] + C[6]  + C[10] )%2;
00607 
00608   myCRC[15] = ( D[63] + D[62] + D[61] + D[60] + D[59] + D[54] +
00609                 D[53] + D[52] + D[51] + D[50] + D[49] + D[48] + 
00610                 D[47] + D[46] + D[45] + D[44] + D[42] + D[40] +
00611                 D[39] + D[38] + D[37] + D[36] + D[35] + D[34] + 
00612                 D[33] + D[32] + D[31] + D[30] + D[29] + D[26] +
00613                 D[25] + D[24] + D[23] + D[22] + D[21] + D[20] + 
00614                 D[19] + D[18] + D[17] + D[16] + D[15] + D[14] +
00615                 D[12] + D[11] + D[10] + D[9]  + D[8]  + D[7]  + 
00616                 D[6]  + D[5]  + D[4]  + D[3]  + D[2]  + D[1]  +
00617                 D[0]  + C[0]  + C[1]  + C[2]  + C[3]  + C[4]  + 
00618                 C[5]  + C[6]  + C[11] + C[12] + C[13] + C[14] +
00619                 C[15] )%2;
00620 
00621   int tempC = 0x0;  
00622   for(int i=0; i<16 ; i++){ tempC = tempC + (myCRC[i]<<i); }
00623   myC = tempC ;
00624   return;
00625 }