MucChain.cxx

Go to the documentation of this file.

//------------------------------------------------------------------------------|
//      [File  ]:                       MucChain.cxx                            |
//      [Brief ]:       Source file of class MucChain for electronics mapping   |
//      [Author]:       Xie Yuguang, <[email protected]>                    |
//      [Date  ]:       Jun 7, 2006                                             |
//      [Log   ]:       See ChangLog                                            |
//------------------------------------------------------------------------------|
 
#include<iostream>
#include<vector>
 
using namespace std;
 
#include "MucMappingAlg/MucChain.h"
 
// Constructor
MucChain :: MucChain( int id, std::string name, int module, int socket, int fecOrder )
{
//  cout << "MucChain:: Create chain : " << endl;
//  cout << "ID: " << id << "\tModule: " << module << "\tSocket: " << socket << "\tFecOrder: " << fecOrder << endl;
    m_ID        = id;
    m_Name      = name;
    m_Module    = module;
    m_Socket    = socket;
    m_FecOrder  = fecOrder;
    
    Mapping();
}
 
// Destructor
MucChain :: ~MucChain()
{
//  cout << "MucChain:: Destructor()." <<endl;
    delete []m_FirstStripID; 
    delete []m_FecLayerID;
    delete []m_StripOrder;
 
    m_FecVect.clear();
}  
 
//----------------------- Set properties methods for public---------------
void MucChain :: ReMap( string name, int module, int socket )
{
    m_Name   = name;
    m_Module = module;
    m_Socket = socket;
 
    MucChain::Mapping();
}
 
void MucChain :: SetFecOrder( int fecOrder )
{
    m_FecOrder = fecOrder;
    
    MucChain::InitFecVect();
}
 
// All FECs
void MucChain :: SetStripOrder( int stripOrder )
{
//      cout << "MucChain:: SetStripOrder( int )." << endl;
    int order;
    if( stripOrder == 0 ) order = DEFAULT_STRIP_ORDER;
    else              order = stripOrder;
 
        for(int i=0; i<m_FecTotal; i++)
            m_StripOrder[ i ] = order;
}
 
void MucChain :: SetStripOrder( int fecID, int stripOrder )
{
    // Decode FecVect member number by fecID
    int i = m_FecOrder * ( fecID - ((1-m_FecOrder)/2)*(m_FecTotal - 1) );
    
    m_FecVect[i].SetStripOrder( stripOrder ); 
} 
 
void MucChain :: ArrayInvert( int* array, int number )
{
    int temp;
    for(int i=0; i<number/2; i++)
    {
        temp          = array[i];
        array[i]      = array[number-1-i];
        array[number-1-i] = temp;
    }
}
 
//------------------------ set properties methods for private---------------
void MucChain :: Mapping()
{   
    InitPart();
  InitSegment();
  InitFecTotal();
    InitFecPerLayer();
  InitFecLayerID();
    InitFirstStripID();
    InitStripOrder();
  InitFecVect();
}
 
void MucChain :: InitPart()
{   
//  cout << "MucChain:: InitPart()." <<endl;
    if( m_Name[0] == 'B' )      m_Part = BRID;
    else if( m_Name[1] == 'E' ) m_Part = EEID;
    else                m_Part = WEID;  
}
 
void MucChain :: InitSegment()
{
//  cout << "MucChain:: InitSegment()." <<endl;
    if( m_Part == BRID )
    {   
        switch( m_Name[2] )
        {
            case '1' : m_Segment = 2; break; 
            case '2' : m_Segment = 1; break;
            case '3' : m_Segment = 0; break;
            case '4' : m_Segment = 7; break;
            case '5' : m_Segment = 6; break;
            case '6' : m_Segment = 5; break;
            case '7' : m_Segment = 4; break;
            case '8' : m_Segment = 3; break;
            default  : ;
        }   
    }
    else if( m_Part == EEID )
    {
        switch( m_Name[2] )
        {
            case '1' : m_Segment = 0; break;
      case '2' : m_Segment = 3; break;
      case '3' : m_Segment = 2; break;
      case '4' : m_Segment = 1; break;
        }
    }
  else
  { 
    switch( m_Name[2] )
    {
      case '1' : m_Segment = 1; break;
      case '2' : m_Segment = 2; break;
      case '3' : m_Segment = 3; break;
      case '4' : m_Segment = 0; break;
    }
  }   
}
 
void MucChain :: InitFecTotal()
{
//  cout << "MucChain:: InitFecTotal()." <<endl;
    if( m_Part == BRID )                // Barrel 
    {
        if( m_Name[1] == 'O' )          // Odd layer chain
        {
            m_FecTotal = FEC_NUM - 1;   // 15 FECs
        }
        else                    // Even layer chain
        {
            if( m_Segment == BRTOP && m_Name[1] == 'E' )    // Top segment
            {
                m_FecTotal = FEC_NUM ;  // 16 FECs
            }   
            else                // Not top segment
            {
                m_FecTotal = FEC_NUM - 4; // 12 FECs
            }
        }
    }
    else                        // Endcap
    {
        m_FecTotal = FEC_NUM;           // 16 FECs
    }
}
 
void MucChain :: InitFecPerLayer()
{
//  cout << "MucChain:: InitFecPerLayer()." <<endl;
    if( m_FecTotal != 0 )
    {
        if( m_FecTotal == FEC_NUM )
            m_FecPerLayer = 4;
        else 
            m_FecPerLayer = 3;
    }
    else
        m_FecPerLayer = 0;
}
 
void MucChain :: InitFecLayerID()
{
  //    cout << "MucChain:: InitLayer()." <<endl;
    // Init array
    for(int i=0; i<FEC_NUM; i++)
        m_FecLayerID[i] = 0;
    
    // Set FEC layer id according to default order
    if( m_Part == BRID )        // Barral chains
    {   
        if( m_Name[1] == 'O' )  // Odd layer chain, layer id: 0, 2, 4, 6, 8 
        {
            for(int i=0; i<m_FecTotal; i++) {
                m_FecLayerID[i] = (i/m_FecPerLayer) * 2;    
            }
        }
        else            // Even layer chain, layer id: 1, 3, 5, 7
        {
            for(int i=0; i<m_FecTotal; i++)  {
                m_FecLayerID[i] = (i/m_FecPerLayer) * 2 + 1;
            }
        }
    }
    else                // Endcap chains
    {
        if( m_Name[3] == 'F' )  // First chain, layer id: 0, 1, 2, 3
        {
            for(int i=0; i<m_FecTotal; i++) {
                m_FecLayerID[i] = 3 - (i/m_FecPerLayer);
            }
        }
        else            // Second chain, layer id: 4, 5, 6, 7
        {
            for(int i=0; i<m_FecTotal; i++) {
                m_FecLayerID[i] = 7 - (i/m_FecPerLayer);
            }
        }
    }
 
    // If inverting order  
    if( m_FecOrder == -1 )
        MucChain::ArrayInvert( &m_FecLayerID[0], m_FecTotal );
 
}
 
void MucChain :: InitFirstStripID()
{
//  cout << "MucChain:: InitFirstStripID()." <<endl;
    // Init array
    for(int i=0; i<FEC_NUM; i++)
        m_FirstStripID[i] = 0;
 
    // Set first strip ID according to default fecOrder
    if( m_Part== BRID )     // Barrel chains
    {
        if( m_Name[1] == 'E' )  // East end, only even number layer chain, layer id: 1, 3, 5, 7
        {
            // Section number is defined by m_FecTotal/m_FecPerLayer
            // Some sections of chain inverting default firstStripID sequence
            
            if(m_Segment==BRTOP)    // BRTOP segment is exceptive, FirstStripID sequence is 64,96,80,48
            {
                for(int i=0; i<m_FecTotal; i++)
                    m_FirstStripID[i] = FIRST_STRID_SQC_BETOP[i%m_FecPerLayer ];
            }
            else switch(m_Segment)
            {
                case 0: ;       // Segment 0, 1, 5, section 0, 2: (+), 1, 3: (-)
                case 1: ;
                case 5:
                    for(int i=0; i<m_FecTotal; i++)
                        m_FirstStripID[i] = FIRST_STRID_SQC_BEA[i%m_FecPerLayer ];
                    break;
                default :   // Other segments 
                    for(int i=0; i<m_FecTotal; i++)
                        m_FirstStripID[i] = FIRST_STRID_SQC_BEB[i%m_FecPerLayer ];
                    
            }
            
        }
        else if( m_Name[1] == 'W' ) // West end, even number layer chain, layer id: 1, 3, 5, 7
        {
        switch(m_Segment)
      {
        case 0: ;               // Segment 0, 1, 2, 5
        case 1: ;
        case 2: ;
                case 5:
            for(int i=0; i<m_FecTotal; i++)
                            m_FirstStripID[i] = FIRST_STRID_SQC_BWA[i%m_FecPerLayer ];
            break;
        default:        // Other segments 
            for(int i=0; i<m_FecTotal; i++)
                            m_FirstStripID[i] = FIRST_STRID_SQC_BWB[i%m_FecPerLayer ];
      }
        } 
        else            // West end, odd number layer chain, layer id: 0, 2, 4, 6
        {   
      switch(m_Segment)
      {
        case 0: ;               // Segment 0, 1, 2, 5
        case 1: ;
        case 2: ;
                case 5:
            for(int i=0; i<m_FecTotal; i++)
                            m_FirstStripID[i] = FIRST_STRID_SQC_BWB[ i%m_FecPerLayer ];
            break;
        default :           // Other segments 
            for(int i=0; i<m_FecTotal; i++)
                            m_FirstStripID[i] = FIRST_STRID_SQC_BWA[ i%m_FecPerLayer ];
      }
        }
 
        // for all chains in Barrel, section 0, 2, 4: (+), 1, 3: (-), inverting 1, 3;
        for(int j=1; j<m_FecTotal/m_FecPerLayer; j+=2) 
            MucChain::ArrayInvert( &m_FirstStripID[j*m_FecPerLayer], m_FecPerLayer );
    }       // End barrel chains
    else        // Endcap chains
    {   
        // Set default firstStripID order(+), no inverting
        for(int i=0; i<m_FecTotal; i++)
            m_FirstStripID[i] = FIRST_STRID_SQC_EC[ i%m_FecPerLayer ];
    }
 
    // If fecOrder inverting
    if( m_FecOrder == -1 )
    {
        MucChain::ArrayInvert( m_FirstStripID, m_FecTotal );
    }
}
 
unsigned int MucChain :: EncodeVmeRecord( int module, int socket, int fecID, unsigned short data)
{
//  cout << "MucChain:: EncodeVmeRecord()." <<endl;
    unsigned int record = ((module << MODULE_BIT) | (socket << SOCKET_BIT) | fecID);
    return ( (record << LENGTH) | data );
}
 
// All FECs
void MucChain :: InitStripOrder()
{
//      cout << "MucChain:: InitStripOrder()." << endl;
 
    
  for(int i=0; i<m_FecTotal; i++)
    {   
        if( m_Part == BRID ) // Barrel          
        {
            m_StripOrder[i] = -1;
/*          
            if( m_Name[1] == 'E' )  // East end, only even number layer chain, layer id: 1, 3, 5, 7
            {   
                // Section number is defined by m_FecTotal/m_FecPerLayer
                // Some sections of chain inverting default strip order
            
                if(m_Segment==BRTOP)    //Strip order is +1, -1, +1, -1
                    
                {
                    for(int i=0; i<m_FecTotal; i++)
                        m_StripOrder[i] = STRORDER_BETOP[i%m_FecPerLayer ];
                }
                else switch(m_Segment)
                {
                    case 0: ;       // Segment 0, 1, 5, section 0, 2: (--+), 1, 3: (+--)
                    case 1: ;
                    case 5:
                        for(int i=0; i<m_FecTotal; i++)
                            m_StripOrder[i] = STRORDER_BEA[i%m_FecPerLayer ];
                        break;
                    default :   // Other segments 
                        for(int i=0; i<m_FecTotal; i++)
                            m_StripOrder[i] = STRORDER_BEB[i%m_FecPerLayer ];
                }           
            }
            else if( m_Name[1] == 'W' ) // West end, even number layer chain, layer id: 1, 3, 5, 7
            {
                            switch(m_Segment)
                            {
                                    case 0: ;               // Segment 0, 1, 2, 5, --+
                                    case 1: ;
                                    case 2: ;
                    case 5:
                                            for(int i=0; i<m_FecTotal; i++)
                            m_StripOrder[i] = STRORDER_BEA[i%m_FecPerLayer ];
                                            break;
                                    default :           // Other segments, +-- 
                                            for(int i=0; i<m_FecTotal; i++)
                            m_StripOrder[i] = STRORDER_BEB[i%m_FecPerLayer ];
                            }
            } 
            else            // West end, odd number layer chain, layer id: 0, 2, 4, 6
            {   
                            for(int i=0; i<m_FecTotal; i++)
                    m_StripOrder[i] = STRORDER_BWO[ i%m_FecPerLayer ];
            }
 
            // for all chains in Barrel, section 0, 2, 4: (+), 1, 3: (-), inverting 1, 3;
            for(int j=1; j<m_FecTotal/m_FecPerLayer; j+=2) 
                MucChain::ArrayInvert( &m_StripOrder[j*m_FecPerLayer], m_FecPerLayer );
*/
        } // End Barrel     
        else if( (m_Part==EEID && (m_Segment==0 || m_Segment==2)) 
             || (m_Part==WEID && (m_Segment==1 || m_Segment==3)) )  
                m_StripOrder[ i ] = STRORDER_ECA[ m_FecLayerID[i] ];
        else 
            m_StripOrder[ i ] = STRORDER_ECB[ m_FecLayerID[i] ];
 
    } // End FecTotal   
 
} 
 
void MucChain :: InitFecVect()
{
//  cout << "MucChain:: InitFecVect()." << endl;
 
    unsigned short data = 0;
 
    int part        = m_Part;
    int segment     = m_Segment;
 
    int id;
    int layer;
    int firstStripID;
    int stripOrder;
    string chainName;
 
    unsigned int vmeRecord;
 
    for(int i=0; i<m_FecTotal; i++)
    {   
        // Encode FEC id by FecVect member number   
        id =( (1 - m_FecOrder)/2 ) * ( m_FecTotal - 1 ) + (m_FecOrder * i);
                
        layer               = m_FecLayerID[ id ];
        firstStripID    = m_FirstStripID[ id ];
        stripOrder      = m_StripOrder[ id ];
        chainName           = MucChain::m_Name;
        vmeRecord       = EncodeVmeRecord( m_Module, m_Socket, id , data);
//    cout << "FEC:\t" << id << "\t" << (vmeRecord>>LENGTH) << endl;
        
        MucFec aFec( id, stripOrder, part, segment, layer, firstStripID, vmeRecord, chainName );
        m_FecVect.push_back( aFec );
    }                   
}
 
// END