Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

MucChain Class Reference

#include <MucChain.h>

List of all members.

Public Member Functions

void ArrayInvert (int *array, int number)
void ArrayInvert (int *array, int number)
MucFec * GetFec (int fecId)
MucFec * GetFec (int fecId)
int GetFecLayerID (int fecID)
int GetFecLayerID (int fecID)
int GetFecOrder ()
int GetFecOrder ()
int GetFecTotal ()
int GetFecTotal ()
vector< MucFec > GetFecVect ()
vector< MucFec > GetFecVect ()
int GetFirstStripID (int fecID)
int GetFirstStripID (int fecID)
int GetID ()
int GetID ()
string GetName ()
string GetName ()
int GetPart ()
int GetPart ()
int GetSegment ()
int GetSegment ()
 MucChain (int id, string name, int module, int socket, int fecOrder)
 MucChain (int id, string name, int module, int socket, int fecOrder)
void ReMap (string name, int module, int socket)
void ReMap (string name, int module, int socket)
void SetFecOrder (int fecOrder)
void SetFecOrder (int fecOrder)
void SetStripOrder (int fecID, int stripOrder)
void SetStripOrder (int stripOrder)
void SetStripOrder (int fecID, int stripOrder)
void SetStripOrder (int stripOrder)
 ~MucChain ()
 ~MucChain ()

Private Member Functions

unsigned int EncodeVmeRecord (int module, int socket, int fecId, unsigned short data)
unsigned int EncodeVmeRecord (int module, int socket, int fecId, unsigned short data)
void InitFecLayerID ()
void InitFecLayerID ()
void InitFecPerLayer ()
void InitFecPerLayer ()
void InitFecTotal ()
void InitFecTotal ()
void InitFecVect ()
void InitFecVect ()
void InitFirstStripID ()
void InitFirstStripID ()
void InitPart ()
void InitPart ()
void InitSegment ()
void InitSegment ()
void InitStripOrder ()
void InitStripOrder ()
void Mapping ()
void Mapping ()

Private Attributes

int m_FecLayerID [FEC_NUM]
int m_FecOrder
int m_FecPerLayer
int m_FecTotal
vector< MucFec > m_FecVect
vector< MucFec > m_FecVect
int m_FirstStripID [FEC_NUM]
int m_ID
int m_Module
string m_Name
int m_Part
int m_Segment
int m_Socket
int m_StripOrder [FEC_NUM]

Constructor & Destructor Documentation

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

00018 {
00019 //      cout << "MucChain:: Create chain : " << endl;
00020 //      cout << "ID: " << id << "\tModule: " << module << "\tSocket: " << socket << "\tFecOrder: " << fecOrder << endl;
00021         m_ID        = id;
00022         m_Name      = name;
00023         m_Module    = module;
00024         m_Socket    = socket;
00025         m_FecOrder  = fecOrder;
00026         
00027         Mapping();
00028 }

MucChain::~MucChain (   ) 
  

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

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

MucChain::~MucChain (   ) 
 

Member Function Documentation

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

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

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]
 

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

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]
  

00059 { return &m_FecVect[fecId];       }

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

00059 { return &m_FecVect[fecId];       }

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

00060 { return m_FecLayerID[fecID];     }

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

00060 { return m_FecLayerID[fecID];     }

int MucChain::GetFecOrder (   )  [inline]
  

00055 { return m_FecOrder;}

int MucChain::GetFecOrder (   )  [inline]
  

00055 { return m_FecOrder;}

int MucChain::GetFecTotal (   )  [inline]
  

00054 { return m_FecTotal;}

int MucChain::GetFecTotal (   )  [inline]
  

00054 { return m_FecTotal;}

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

00057 { return m_FecVect;     }

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

00057 { return m_FecVect;     }

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

00061 { return m_FirstStripID[fecID]; }

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

00061 { return m_FirstStripID[fecID]; }

int MucChain::GetID (   )  [inline]
  

00051 { return m_ID;            }

int MucChain::GetID (   )  [inline]
  

00051 { return m_ID;            }

string MucChain::GetName (   )  [inline]
  

00056 { return m_Name;          }

string MucChain::GetName (   )  [inline]
  

00056 { return m_Name;          }

int MucChain::GetPart (   )  [inline]
  

00052 { return m_Part;          }

int MucChain::GetPart (   )  [inline]
  

00052 { return m_Part;          }

int MucChain::GetSegment (   )  [inline]
  

00053 { return m_Segment; }

int MucChain::GetSegment (   )  [inline]
  

00053 { return m_Segment; }

void MucChain::InitFecLayerID (   )  [private]
 

void MucChain::InitFecLayerID (   )  [private]
  

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]
 

void MucChain::InitFecPerLayer (   )  [private]
  

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]
 

void MucChain::InitFecTotal (   )  [private]
  

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]
 

void MucChain::InitFecVect (   )  [private]
  

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]
 

void MucChain::InitFirstStripID (   )  [private]
  

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]
 

void MucChain::InitPart (   )  [private]
  

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]
 

void MucChain::InitSegment (   )  [private]
  

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]
 

void MucChain::InitStripOrder (   )  [private]
  

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]
 

void MucChain::Mapping (   )  [private]
  

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
) 
 

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

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

void MucChain::SetFecOrder (  int  fecOrder  ) 
 

void MucChain::SetFecOrder (  int  fecOrder  ) 
  

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

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

void MucChain::SetStripOrder (  int  stripOrder  ) 
 

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

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  ) 
  

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 }

Member Data Documentation

int MucChain::m_FecLayerID [private]
 

int MucChain::m_FecOrder [private]
 

int MucChain::m_FecPerLayer [private]
 

int MucChain::m_FecTotal [private]
 

vector< MucFec> MucChain::m_FecVect [private]
 

vector< MucFec> MucChain::m_FecVect [private]
 

int MucChain::m_FirstStripID [private]
 

int MucChain::m_ID [private]
 

int MucChain::m_Module [private]
 

string MucChain::m_Name [private]
 

int MucChain::m_Part [private]
 

int MucChain::m_Segment [private]
 

int MucChain::m_Socket [private]
 

int MucChain::m_StripOrder [private]
 

The documentation for this class was generated from the following files:
Generated on Wed Feb 2 16:33:47 2011 for BOSS6.5.5 by  doxygen 1.3.9.1