BOSS_7.0.2: MucChain Class Reference

MucChain::MucChain	(	int	id,
		string	name,
		int	module,
		int	socket,
		int	fecOrder
	)

MucChain::~MucChain ( )

Definition at line 31 of file MucChain.cxx.

References m_FecLayerID, m_FecVect, m_FirstStripID, and m_StripOrder.

00032 {
00033 //      cout << "MucChain:: Destructor()." <<endl;
00034         delete []m_FirstStripID; 
00035         delete []m_FecLayerID;
00036         delete []m_StripOrder;
00037 
00038         m_FecVect.clear();
00039 }

void MucChain::ArrayInvert	(	int *	array,
		int	number
	)

Definition at line 78 of file MucChain.cxx.

References genRecEmupikp::i, and subSeperate::temp.

Referenced by InitFecLayerID(), and InitFirstStripID().

00079 {
00080         int temp;
00081         for(int i=0; i<number/2; i++)
00082         {
00083                 temp              = array[i];
00084                 array[i]          = array[number-1-i];
00085                 array[number-1-i] = temp;
00086         }
00087 }

unsigned int MucChain::EncodeVmeRecord	(	int	module,
		int	socket,
		int	fecId,
		unsigned short	data
	)			`[private]`

Definition at line 322 of file MucChain.cxx.

References LENGTH, MODULE_BIT, and SOCKET_BIT.

Referenced by InitFecVect().

00323 {
00324 //      cout << "MucChain:: EncodeVmeRecord()." <<endl;
00325         unsigned int record = ((module << MODULE_BIT) | (socket << SOCKET_BIT) | fecID);
00326         return ( (record << LENGTH) | data );
00327 }

MucFec* MucChain::GetFec ( int fecId ) [inline]

Definition at line 59 of file MucChain.h.

References m_FecVect.

00059 { return &m_FecVect[fecId];       }

int MucChain::GetFecLayerID ( int fecID ) [inline]

Definition at line 60 of file MucChain.h.

References m_FecLayerID.

00060 { return m_FecLayerID[fecID];     }

int MucChain::GetFecOrder ( ) [inline]

Definition at line 55 of file MucChain.h.

References m_FecOrder.

00055 { return m_FecOrder;}

int MucChain::GetFecTotal ( ) [inline]

Definition at line 54 of file MucChain.h.

References m_FecTotal.

Referenced by MucMappingAlg::finalize().

00054 { return m_FecTotal;}

vector< MucFec> MucChain::GetFecVect ( ) [inline]

Definition at line 57 of file MucChain.h.

References m_FecVect.

00057 { return m_FecVect;     }

int MucChain::GetFirstStripID ( int fecID ) [inline]

Definition at line 61 of file MucChain.h.

References m_FirstStripID.

00061 { return m_FirstStripID[fecID]; }

int MucChain::GetID ( ) [inline]

Definition at line 51 of file MucChain.h.

References m_ID.

00051 { return m_ID;            }

string MucChain::GetName ( ) [inline]

Definition at line 56 of file MucChain.h.

References m_Name.

00056 { return m_Name;          }

int MucChain::GetPart ( ) [inline]

Definition at line 52 of file MucChain.h.

References m_Part.

Referenced by MucMappingAlg::finalize().

00052 { return m_Part;          }

int MucChain::GetSegment ( ) [inline]

Definition at line 53 of file MucChain.h.

References m_Segment.

00053 { return m_Segment; }

void MucChain::InitFecLayerID ( ) [private]

Definition at line 191 of file MucChain.cxx.

References ArrayInvert(), BRID, FEC_NUM, genRecEmupikp::i, m_FecLayerID, m_FecOrder, m_FecPerLayer, m_FecTotal, m_Name, and m_Part.

Referenced by Mapping().

00192 {
00193   //    cout << "MucChain:: InitLayer()." <<endl;
00194         // Init array
00195         for(int i=0; i<FEC_NUM; i++)
00196                 m_FecLayerID[i] = 0;
00197         
00198         // Set FEC layer id according to default order
00199         if( m_Part == BRID )            // Barral chains
00200         {       
00201                 if( m_Name[1] == 'O' )  // Odd layer chain, layer id: 0, 2, 4, 6, 8 
00202                 {
00203                         for(int i=0; i<m_FecTotal; i++) {
00204                                 m_FecLayerID[i] = (i/m_FecPerLayer) * 2;        
00205                         }
00206                 }
00207                 else                    // Even layer chain, layer id: 1, 3, 5, 7
00208                 {
00209                         for(int i=0; i<m_FecTotal; i++)  {
00210                                 m_FecLayerID[i] = (i/m_FecPerLayer) * 2 + 1;
00211                         }
00212                 }
00213         }
00214         else                            // Endcap chains
00215         {
00216                 if( m_Name[3] == 'F' )  // First chain, layer id: 0, 1, 2, 3
00217                 {
00218                         for(int i=0; i<m_FecTotal; i++) {
00219                                 m_FecLayerID[i] = 3 - (i/m_FecPerLayer);
00220                         }
00221                 }
00222                 else                    // Second chain, layer id: 4, 5, 6, 7
00223                 {
00224                         for(int i=0; i<m_FecTotal; i++) {
00225                                 m_FecLayerID[i] = 7 - (i/m_FecPerLayer);
00226                         }
00227                 }
00228         }
00229 
00230         // If inverting order  
00231         if( m_FecOrder == -1 )
00232                 MucChain::ArrayInvert( &m_FecLayerID[0], m_FecTotal );
00233 
00234 }

void MucChain::InitFecPerLayer ( ) [private]

Definition at line 177 of file MucChain.cxx.

References FEC_NUM, m_FecPerLayer, and m_FecTotal.

Referenced by Mapping().

00178 {
00179 //      cout << "MucChain:: InitFecPerLayer()." <<endl;
00180         if( m_FecTotal != 0 )
00181         {
00182                 if( m_FecTotal == FEC_NUM )
00183                         m_FecPerLayer = 4;
00184                 else 
00185                         m_FecPerLayer = 3;
00186         }
00187         else
00188                 m_FecPerLayer = 0;
00189 }

void MucChain::InitFecTotal ( ) [private]

Definition at line 150 of file MucChain.cxx.

References BRID, BRTOP, FEC_NUM, m_FecTotal, m_Name, m_Part, and m_Segment.

Referenced by Mapping().

00151 {
00152 //      cout << "MucChain:: InitFecTotal()." <<endl;
00153         if( m_Part == BRID )                            // Barrel 
00154         {
00155                 if( m_Name[1] == 'O' )                  // Odd layer chain
00156                 {
00157                         m_FecTotal = FEC_NUM - 1;       // 15 FECs
00158                 }
00159                 else                                    // Even layer chain
00160                 {
00161                         if( m_Segment == BRTOP && m_Name[1] == 'E' )    // Top segment
00162                         {
00163                                 m_FecTotal = FEC_NUM ;  // 16 FECs
00164                         }       
00165                         else                            // Not top segment
00166                         {
00167                                 m_FecTotal = FEC_NUM - 4; // 12 FECs
00168                         }
00169                 }
00170         }
00171         else                                            // Endcap
00172         {
00173                 m_FecTotal = FEC_NUM;                   // 16 FECs
00174         }
00175 }

void MucChain::InitFecVect ( ) [private]

Definition at line 402 of file MucChain.cxx.

References EncodeVmeRecord(), genRecEmupikp::i, m_FecLayerID, m_FecOrder, m_FecTotal, m_FecVect, m_FirstStripID, m_Module, m_Name, m_Part, m_Segment, m_Socket, m_StripOrder, and deljobs::string.

Referenced by Mapping(), and SetFecOrder().

00403 {
00404 //      cout << "MucChain:: InitFecVect()." << endl;
00405 
00406         unsigned short data = 0;
00407 
00408         int part        = m_Part;
00409         int segment     = m_Segment;
00410 
00411         int id;
00412         int layer;
00413         int firstStripID;
00414         int stripOrder;
00415         string chainName;
00416 
00417         unsigned int vmeRecord;
00418 
00419         for(int i=0; i<m_FecTotal; i++)
00420         {       
00421                 // Encode FEC id by FecVect member number       
00422                 id =( (1 - m_FecOrder)/2 ) * ( m_FecTotal - 1 ) + (m_FecOrder * i);
00423                                 
00424                 layer                           = m_FecLayerID[ id ];
00425                 firstStripID    = m_FirstStripID[ id ];
00426                 stripOrder              = m_StripOrder[ id ];
00427                 chainName                       = MucChain::m_Name;
00428                 vmeRecord               = EncodeVmeRecord( m_Module, m_Socket, id , data);
00429 //    cout << "FEC:\t" << id << "\t" << (vmeRecord>>LENGTH) << endl;
00430                 
00431                 MucFec aFec( id, stripOrder, part, segment, layer, firstStripID, vmeRecord, chainName );
00432                 m_FecVect.push_back( aFec );
00433         }                                       
00434 }

void MucChain::InitFirstStripID ( ) [private]

Definition at line 236 of file MucChain.cxx.

References ArrayInvert(), BRID, BRTOP, FEC_NUM, FIRST_STRID_SQC_BEA, FIRST_STRID_SQC_BEB, FIRST_STRID_SQC_BETOP, FIRST_STRID_SQC_BWA, FIRST_STRID_SQC_BWB, FIRST_STRID_SQC_EC, genRecEmupikp::i, ganga-rec::j, m_FecOrder, m_FecPerLayer, m_FecTotal, m_FirstStripID, m_Name, m_Part, and m_Segment.

Referenced by Mapping().

00237 {
00238 //      cout << "MucChain:: InitFirstStripID()." <<endl;
00239         // Init array
00240         for(int i=0; i<FEC_NUM; i++)
00241                 m_FirstStripID[i] = 0;
00242 
00243         // Set first strip ID according to default fecOrder
00244         if( m_Part== BRID )             // Barrel chains
00245         {
00246                 if( m_Name[1] == 'E' )  // East end, only even number layer chain, layer id: 1, 3, 5, 7
00247                 {
00248                         // Section number is defined by m_FecTotal/m_FecPerLayer
00249                         // Some sections of chain inverting default firstStripID sequence
00250                         
00251                         if(m_Segment==BRTOP)    // BRTOP segment is exceptive, FirstStripID sequence is 64,96,80,48
00252                         {
00253                                 for(int i=0; i<m_FecTotal; i++)
00254                                         m_FirstStripID[i] = FIRST_STRID_SQC_BETOP[i%m_FecPerLayer ];
00255                         }
00256                         else switch(m_Segment)
00257                         {
00258                                 case 0: ;               // Segment 0, 1, 5, section 0, 2: (+), 1, 3: (-)
00259                                 case 1: ;
00260                                 case 5:
00261                                         for(int i=0; i<m_FecTotal; i++)
00262                                                 m_FirstStripID[i] = FIRST_STRID_SQC_BEA[i%m_FecPerLayer ];
00263                                         break;
00264                                 default :       // Other segments 
00265                                         for(int i=0; i<m_FecTotal; i++)
00266                                                 m_FirstStripID[i] = FIRST_STRID_SQC_BEB[i%m_FecPerLayer ];
00267                                         
00268                         }
00269                         
00270                 }
00271                 else if( m_Name[1] == 'W' ) // West end, even number layer chain, layer id: 1, 3, 5, 7
00272                 {
00273         switch(m_Segment)
00274       {
00275         case 0: ;               // Segment 0, 1, 2, 5
00276         case 1: ;
00277         case 2: ;
00278                                 case 5:
00279             for(int i=0; i<m_FecTotal; i++)
00280                                                         m_FirstStripID[i] = FIRST_STRID_SQC_BWA[i%m_FecPerLayer ];
00281             break;
00282         default:        // Other segments 
00283             for(int i=0; i<m_FecTotal; i++)
00284                                                         m_FirstStripID[i] = FIRST_STRID_SQC_BWB[i%m_FecPerLayer ];
00285       }
00286                 } 
00287                 else                    // West end, odd number layer chain, layer id: 0, 2, 4, 6
00288                 {       
00289       switch(m_Segment)
00290       {
00291         case 0: ;               // Segment 0, 1, 2, 5
00292         case 1: ;
00293         case 2: ;
00294                                 case 5:
00295                 for(int i=0; i<m_FecTotal; i++)
00296                                                         m_FirstStripID[i] = FIRST_STRID_SQC_BWB[ i%m_FecPerLayer ];
00297             break;
00298         default :               // Other segments 
00299             for(int i=0; i<m_FecTotal; i++)
00300                                                         m_FirstStripID[i] = FIRST_STRID_SQC_BWA[ i%m_FecPerLayer ];
00301       }
00302                 }
00303 
00304                 // for all chains in Barrel, section 0, 2, 4: (+), 1, 3: (-), inverting 1, 3;
00305                 for(int j=1; j<m_FecTotal/m_FecPerLayer; j+=2) 
00306                         MucChain::ArrayInvert( &m_FirstStripID[j*m_FecPerLayer], m_FecPerLayer );
00307         }               // End barrel chains
00308         else            // Endcap chains
00309         {       
00310                 // Set default firstStripID order(+), no inverting
00311                 for(int i=0; i<m_FecTotal; i++)
00312                         m_FirstStripID[i] = FIRST_STRID_SQC_EC[ i%m_FecPerLayer ];
00313         }
00314 
00315         // If fecOrder inverting
00316         if( m_FecOrder == -1 )
00317         {
00318                 MucChain::ArrayInvert( m_FirstStripID, m_FecTotal );
00319         }
00320 }

void MucChain::InitPart ( ) [private]

Definition at line 102 of file MucChain.cxx.

References BRID, EEID, m_Name, m_Part, and WEID.

Referenced by Mapping().

00103 {       
00104 //      cout << "MucChain:: InitPart()." <<endl;
00105         if( m_Name[0] == 'B' )          m_Part = BRID;
00106         else if( m_Name[1] == 'E' )     m_Part = EEID;
00107         else                            m_Part = WEID;  
00108 }

void MucChain::InitSegment ( ) [private]

Definition at line 110 of file MucChain.cxx.

References BRID, EEID, m_Name, m_Part, and m_Segment.

Referenced by Mapping().

00111 {
00112 //      cout << "MucChain:: InitSegment()." <<endl;
00113         if( m_Part == BRID )
00114         {       
00115                 switch( m_Name[2] )
00116                 {
00117                         case '1' : m_Segment = 2; break; 
00118                         case '2' : m_Segment = 1; break;
00119                         case '3' : m_Segment = 0; break;
00120                         case '4' : m_Segment = 7; break;
00121                         case '5' : m_Segment = 6; break;
00122                         case '6' : m_Segment = 5; break;
00123                         case '7' : m_Segment = 4; break;
00124                         case '8' : m_Segment = 3; break;
00125                         default  : ;
00126                 }       
00127         }
00128         else if( m_Part == EEID )
00129         {
00130                 switch( m_Name[2] )
00131                 {
00132                         case '1' : m_Segment = 0; break;
00133       case '2' : m_Segment = 3; break;
00134       case '3' : m_Segment = 2; break;
00135       case '4' : m_Segment = 1; break;
00136                 }
00137         }
00138   else
00139   { 
00140     switch( m_Name[2] )
00141     {
00142       case '1' : m_Segment = 1; break;
00143       case '2' : m_Segment = 2; break;
00144       case '3' : m_Segment = 3; break;
00145       case '4' : m_Segment = 0; break;
00146     }
00147   }   
00148 }

void MucChain::InitStripOrder ( ) [private]

Definition at line 330 of file MucChain.cxx.

References BRID, EEID, genRecEmupikp::i, m_FecLayerID, m_FecTotal, m_Part, m_Segment, m_StripOrder, STRORDER_ECA, STRORDER_ECB, and WEID.

Referenced by Mapping().

00331 {
00332 //      cout << "MucChain:: InitStripOrder()." << endl;
00333 
00334         
00335   for(int i=0; i<m_FecTotal; i++)
00336         {       
00337                 if( m_Part == BRID ) // Barrel                  
00338                 {
00339                         m_StripOrder[i] = -1;
00340 /*                      
00341                         if( m_Name[1] == 'E' )  // East end, only even number layer chain, layer id: 1, 3, 5, 7
00342                         {       
00343                                 // Section number is defined by m_FecTotal/m_FecPerLayer
00344                                 // Some sections of chain inverting default strip order
00345                         
00346                                 if(m_Segment==BRTOP)    //Strip order is +1, -1, +1, -1
00347                                         
00348                                 {
00349                                         for(int i=0; i<m_FecTotal; i++)
00350                                                 m_StripOrder[i] = STRORDER_BETOP[i%m_FecPerLayer ];
00351                                 }
00352                                 else switch(m_Segment)
00353                                 {
00354                                         case 0: ;               // Segment 0, 1, 5, section 0, 2: (--+), 1, 3: (+--)
00355                                         case 1: ;
00356                                         case 5:
00357                                                 for(int i=0; i<m_FecTotal; i++)
00358                                                         m_StripOrder[i] = STRORDER_BEA[i%m_FecPerLayer ];
00359                                                 break;
00360                                         default :       // Other segments 
00361                                                 for(int i=0; i<m_FecTotal; i++)
00362                                                         m_StripOrder[i] = STRORDER_BEB[i%m_FecPerLayer ];
00363                                 }                       
00364                         }
00365                         else if( m_Name[1] == 'W' ) // West end, even number layer chain, layer id: 1, 3, 5, 7
00366                         {
00367                                 switch(m_Segment)
00368                                 {
00369                                         case 0: ;               // Segment 0, 1, 2, 5, --+
00370                                         case 1: ;
00371                                         case 2: ;
00372                                         case 5:
00373                                                 for(int i=0; i<m_FecTotal; i++)
00374                                                         m_StripOrder[i] = STRORDER_BEA[i%m_FecPerLayer ];
00375                                                 break;
00376                                         default :               // Other segments, +-- 
00377                                                 for(int i=0; i<m_FecTotal; i++)
00378                                                         m_StripOrder[i] = STRORDER_BEB[i%m_FecPerLayer ];
00379                                 }
00380                         } 
00381                         else                    // West end, odd number layer chain, layer id: 0, 2, 4, 6
00382                         {       
00383                                 for(int i=0; i<m_FecTotal; i++)
00384                                         m_StripOrder[i] = STRORDER_BWO[ i%m_FecPerLayer ];
00385                         }
00386 
00387                         // for all chains in Barrel, section 0, 2, 4: (+), 1, 3: (-), inverting 1, 3;
00388                         for(int j=1; j<m_FecTotal/m_FecPerLayer; j+=2) 
00389                                 MucChain::ArrayInvert( &m_StripOrder[j*m_FecPerLayer], m_FecPerLayer );
00390 */
00391                 } // End Barrel         
00392                 else if( (m_Part==EEID && (m_Segment==0 || m_Segment==2)) 
00393                          || (m_Part==WEID && (m_Segment==1 || m_Segment==3)) )  
00394                         m_StripOrder[ i ] = STRORDER_ECA[ m_FecLayerID[i] ];
00395                 else 
00396                         m_StripOrder[ i ] = STRORDER_ECB[ m_FecLayerID[i] ];
00397 
00398         } // End FecTotal       
00399 
00400 }

void MucChain::Mapping ( ) [private]

Definition at line 90 of file MucChain.cxx.

References InitFecLayerID(), InitFecPerLayer(), InitFecTotal(), InitFecVect(), InitFirstStripID(), InitPart(), InitSegment(), and InitStripOrder().

Referenced by ReMap().

00091 {       
00092         InitPart();
00093   InitSegment();
00094   InitFecTotal();
00095         InitFecPerLayer();
00096   InitFecLayerID();
00097         InitFirstStripID();
00098         InitStripOrder();
00099   InitFecVect();
00100 }

void MucChain::ReMap	(	string	name,
		int	module,
		int	socket
	)

Definition at line 42 of file MucChain.cxx.

References m_Module, m_Name, m_Socket, and Mapping().

00043 {
00044         m_Name   = name;
00045         m_Module = module;
00046         m_Socket = socket;
00047 
00048         MucChain::Mapping();
00049 }

void MucChain::SetFecOrder ( int fecOrder )

Definition at line 51 of file MucChain.cxx.

References InitFecVect(), and m_FecOrder.

00052 {
00053         m_FecOrder = fecOrder;
00054         
00055         MucChain::InitFecVect();
00056 }

void MucChain::SetStripOrder	(	int	fecID,
		int	stripOrder
	)

Definition at line 70 of file MucChain.cxx.

References genRecEmupikp::i, m_FecOrder, m_FecTotal, and m_FecVect.

00071 {
00072         // Decode FecVect member number by fecID
00073         int i = m_FecOrder * ( fecID - ((1-m_FecOrder)/2)*(m_FecTotal - 1) );
00074         
00075         m_FecVect[i].SetStripOrder( stripOrder ); 
00076 }

void MucChain::SetStripOrder ( int stripOrder )

Definition at line 59 of file MucChain.cxx.

References DEFAULT_STRIP_ORDER, genRecEmupikp::i, m_FecTotal, and m_StripOrder.

00060 {
00061 //      cout << "MucChain:: SetStripOrder( int )." << endl;
00062         int order;
00063         if( stripOrder == 0 ) order = DEFAULT_STRIP_ORDER;
00064         else                  order = stripOrder;
00065 
00066         for(int i=0; i<m_FecTotal; i++)
00067                 m_StripOrder[ i ] = order;
00068 }

int MucChain::m_FecLayerID[FEC_NUM] [private]

Definition at line 78 of file MucChain.h.

Referenced by GetFecLayerID(), InitFecLayerID(), InitFecVect(), InitStripOrder(), and ~MucChain().

int MucChain::m_FecOrder [private]

Definition at line 75 of file MucChain.h.

Referenced by GetFecOrder(), InitFecLayerID(), InitFecVect(), InitFirstStripID(), SetFecOrder(), and SetStripOrder().

int MucChain::m_FecPerLayer [private]

Definition at line 80 of file MucChain.h.

Referenced by InitFecLayerID(), InitFecPerLayer(), and InitFirstStripID().

int MucChain::m_FecTotal [private]

Definition at line 79 of file MucChain.h.

Referenced by GetFecTotal(), InitFecLayerID(), InitFecPerLayer(), InitFecTotal(), InitFecVect(), InitFirstStripID(), InitStripOrder(), and SetStripOrder().

vector< MucFec> MucChain::m_FecVect [private]

Definition at line 83 of file MucChain.h.

Referenced by GetFec(), GetFecVect(), InitFecVect(), SetStripOrder(), and ~MucChain().

int MucChain::m_FirstStripID[FEC_NUM] [private]

Definition at line 81 of file MucChain.h.

Referenced by GetFirstStripID(), InitFecVect(), InitFirstStripID(), and ~MucChain().

int MucChain::m_ID [private]

Definition at line 71 of file MucChain.h.

Referenced by GetID().

int MucChain::m_Module [private]

Definition at line 73 of file MucChain.h.

Referenced by InitFecVect(), and ReMap().

string MucChain::m_Name [private]

Definition at line 72 of file MucChain.h.

Referenced by GetName(), InitFecLayerID(), InitFecTotal(), InitFecVect(), InitFirstStripID(), InitPart(), InitSegment(), and ReMap().

int MucChain::m_Part [private]

Definition at line 76 of file MucChain.h.

Referenced by GetPart(), InitFecLayerID(), InitFecTotal(), InitFecVect(), InitFirstStripID(), InitPart(), InitSegment(), and InitStripOrder().

int MucChain::m_Segment [private]

Definition at line 77 of file MucChain.h.

Referenced by GetSegment(), InitFecTotal(), InitFecVect(), InitFirstStripID(), InitSegment(), and InitStripOrder().

int MucChain::m_Socket [private]

Definition at line 74 of file MucChain.h.

Referenced by InitFecVect(), and ReMap().

int MucChain::m_StripOrder[FEC_NUM] [private]

Definition at line 82 of file MucChain.h.

Referenced by InitFecVect(), InitStripOrder(), SetStripOrder(), and ~MucChain().

MucChain Class Reference

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation


Public Member Functions
	MucChain (int id, string name, int module, int socket, int fecOrder)
	~MucChain ()
int	GetID ()
int	GetPart ()
int	GetSegment ()
int	GetFecTotal ()
int	GetFecOrder ()
string	GetName ()
vector< MucFec >	GetFecVect ()
MucFec *	GetFec (int fecId)
int	GetFecLayerID (int fecID)
int	GetFirstStripID (int fecID)
void	ReMap (string name, int module, int socket)
void	SetFecOrder (int fecOrder)
void	SetStripOrder (int stripOrder)
void	SetStripOrder (int fecID, int stripOrder)
void	ArrayInvert (int *array, int number)
Private Member Functions
void	Mapping ()
void	InitPart ()
void	InitSegment ()
void	InitFecTotal ()
void	InitFecPerLayer ()
void	InitFecLayerID ()
void	InitFirstStripID ()
void	InitStripOrder ()
unsigned int	EncodeVmeRecord (int module, int socket, int fecId, unsigned short data)
void	InitFecVect ()
Private Attributes
int	m_ID
string	m_Name
int	m_Module
int	m_Socket
int	m_FecOrder
int	m_Part
int	m_Segment
int	m_FecLayerID [FEC_NUM]
int	m_FecTotal
int	m_FecPerLayer
int	m_FirstStripID [FEC_NUM]
int	m_StripOrder [FEC_NUM]
vector< MucFec >	m_FecVect