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