MucFec.cxx

Go to the documentation of this file.

//------------------------------------------------------------------------------|
//      [File  ]:                       MucFec.cxx                              |
//      [Brief ]:       Source file of class MucFec for electronics mapping     |
//      [Author]:       Xie Yuguang, <[email protected]>                    |
//      [Date  ]:       Jun 7, 2006                                             |
//      [Log   ]:       See ChangLog                                            |
//------------------------------------------------------------------------------|
 
#include<iostream>
#include<vector>
 
using namespace std;
 
#include "MucMappingAlg/MucFec.h"
#include "MucMappingAlg/MucGeoConst.h"
 
// Constructor
MucFec :: MucFec(int id )
{
  //cout << "MucFec:: Create FEC : " << id << endl;
  
  if( (id < 0) || (id > STRIP_NUM-1) ) {
    cout << "Initialize failure, check id!" << endl;
    m_ID = 0;
  }
  else  m_ID = id;
  
  m_Part          = 0;
  m_Segment       = 0;
  m_Layer         = 0;
  m_FirstStripID  = 0;
  m_StripOrder    = DEFAULT_STRIP_ORDER;
  m_ChainName     = "NoName";
  m_VmeRecord     = 0;
  
  MucFec::Initialize();
}
 
MucFec :: MucFec( int id, int stripOrder, int part, int segment, int layer, int firstStripID, 
                  unsigned int vmeRecord, string chainName)
{
  // cout << "MucFec:: Create FEC : " << endl;
  // cout << "ID: " << id << "\tPart: " << part << "\tSegment: " << segment << "\tLayer: " << layer 
  //      << "\tfirstStripID: " << firstStripID << "\tvmeRecord: " << vmeRecord<<endl;
 
  // Check parameters   
  if( (id < 0) || (id > STRIP_NUM-1) ) {
    m_ID =  0; 
    cout << "MucFec::Check id:\t" << id << "!" << endl;
  }else
  if( (stripOrder != 1) && (stripOrder != -1) ) {
    m_StripOrder = 0;
    cout << "MucFec::Check stripOrder:\t" << stripOrder << "!" << endl;
  }else
  if( (part < 0) || ( part > PART_MAX-1) ) {
    m_Part =  0;
    cout << "MucFec::Check part:\t" << part << "!" << endl;
  }else
  if( (segment < 0) || ( segment > ((part==BRID)?(B_SEG_NUM-1):(E_SEG_NUM-1)) ) ) {
    m_Segment =  0;
    cout << "MucFec::Check segment:\t" << segment << "!" << endl;
  }else
  if( (layer <0) || ( layer > ((part==BRID)?(B_LAY_NUM-1):(E_LAY_NUM-1)) ) ) {
    m_Layer = 0;
    cout << "MucFec::Check layer:\t" << layer << "!" << endl;
  }else
  if( sizeof(vmeRecord) < 4 ) {
    m_VmeRecord = 0;
    cout << "MucFec::Check record:\t" << vmeRecord << "!" << endl;
  }else
  {
    m_ID            = id;
    m_StripOrder    = stripOrder;
    m_Part          = part;
    m_Segment       = segment;
    m_Layer         = layer;
    m_FirstStripID  = firstStripID;
    m_ChainName     = chainName;
    m_VmeRecord     = vmeRecord;
  }
  
  MucFec::Initialize(); 
}
 
void MucFec :: Initialize()
{
  MucFec::DecodeData();
  MucFec::DecodeVmeAddress();
  MucFec::SetFiredStripNumber();
  MucFec::SetFiredStripVect();
  MucFec::EncodePowerpcRecord();
}
 
//----------------------------------Set methods---------------------------------------
void MucFec :: DecodeData()
{
  m_Data = (unsigned short)m_VmeRecord;
}   
 
void MucFec :: DecodeVmeAddress() 
{
  m_VmeAddress  = (unsigned short)(m_VmeRecord >> LENGTH);  // high 16 bits, 10 bits used
  m_Module      = (m_VmeAddress >> MODULE_BIT) & 0xF; // 4 bits
  m_Socket      = (m_VmeAddress >> SOCKET_BIT) & 0x3; // 2 bits
  m_FecID       = m_VmeAddress & 0xF; // 4 bits 
}
 
void MucFec :: SetFiredStripNumber() 
{
  m_FiredStripNumber = 0;
  for(int i=0; i<STRIP_NUM; i++) {
    if( (m_Data>>i) & 1 ) m_FiredStripNumber++;
  } 
}
 
void MucFec :: SetFiredStripVect()
{
  m_FiredStripVect.clear();
  int tempID[STRIP_NUM];
  int tempFired=0;
  
  for(int i=0; i<STRIP_NUM; i++)
  {
    if( (m_Data>>i) & 1 ) {
      tempID[tempFired] = i;    
      tempFired++;
    }   
  }
  
  int stripID = 0;  
  for(int i=0; i<tempFired; i++)
  {
    stripID = ((1 - m_StripOrder)/2) * (STRIP_NUM - 1) + (m_StripOrder * tempID[i]);
    stripID += m_FirstStripID;
    m_FiredStripVect.push_back( stripID );
  } 
}
 
void MucFec :: EncodePowerpcRecord()
{   
  unsigned int address  = ( (m_Part<<PART_BIT) | (m_Segment<<SEG_BIT) | (m_Layer<<LAY_BIT) | m_FirstStripID );
  m_GeoAddress          = (unsigned short)address;
  m_PowerpcRecord       = ( address << LENGTH ) | m_Data;
}
 
void MucFec :: SetStripOrder( int stripOrder )
{
  m_StripOrder = stripOrder;    
  MucFec::SetFiredStripVect();  
}
 
void MucFec :: SetLocation( int part, int segment, int layer )
{
  m_Part    = part;
  m_Segment = segment;
  m_Layer   = layer;
  
  MucFec::Initialize();
}
 
void MucFec :: SetFirstStripID( int firstStripID )
{
  m_FirstStripID = firstStripID;
  MucFec :: EncodePowerpcRecord();
  MucFec :: SetFiredStripVect();
}
 
void MucFec :: SetData( unsigned short data )
{
  m_Data      = data;
  m_VmeRecord = (m_VmeRecord | m_Data);
  MucFec :: EncodePowerpcRecord();
  MucFec :: SetFiredStripNumber();
  MucFec :: SetFiredStripVect();
}
 
//-------------------------- Get methods --------------------------------
int          MucFec :: GetFiredStripNumber()  { return m_FiredStripNumber;  }
unsigned int MucFec :: GetPowerpcRecord()     { return m_PowerpcRecord;     }
vector< int >*  MucFec :: GetFiredStripVect() { return &m_FiredStripVect;   }
 
string MucFec :: GetBin( unsigned int record )
{
  const int SIZE = sizeof( unsigned int ) * 8;
  
  string Bin;
  unsigned int temp = 0;
  for(int i=0; i<SIZE; i++) {
    temp = record >> SIZE-i-1;
    Bin += ( temp & 1 ) ? "1" : "0";
  }
  
  return Bin;
}
 
string MucFec :: GetBin( unsigned short record )
{
  const int SIZE = sizeof( unsigned short ) * 8;
  
  string Bin;
  unsigned short temp = 0;
  for(int i=0; i<SIZE; i++) {
    temp = record >> SIZE-i-1;
    Bin += ( temp & 1 ) ? "1" : "0";
  }
  
  return Bin;
}
 
string MucFec :: GetVmeBin()
{
  return MucFec::GetBin( m_VmeAddress );
}
 
string MucFec :: GetGeoBin()
{
  return MucFec::GetBin( m_GeoAddress );
}
 
string MucFec :: GetDataBin()
{
  return MucFec::GetBin( m_Data );
}
 
 
 
// END