MucID.cxx

Go to the documentation of this file.

#include "Identifier/MucID.h"
#include <assert.h>
 
const unsigned int MucID::CHANNEL_BARREL_LAYER_NUM[MucID::LAYER_BARREL_NUM] = {
    64, 112, 64, 112, 64, 112, 64, 112, 64 }; // change 96 to 112. 2006.10.20
 
MucID::MucID( void ) {}
 
MucID::~MucID( void ) {}
 
//----------------------------------------------------------------------------
bool MucID::values_ok( const unsigned int barrel_ec, const unsigned int segment,
                       const unsigned int layer, const unsigned int channel ) {
  // Check values
  if ( barrel_ec >= BARREL_EC_NUM ) return false;
  if ( barrel_ec == 0 || barrel_ec == BARREL_EC_NUM - 1 )
  {
    if ( segment >= SEGMENT_ENDCAP_NUM ) return false;
    if ( layer >= LAYER_ENDCAP_NUM ) return false;
    if ( channel >= CHANNEL_ENDCAP_NUM_MAX ) return false;
  }
  else
  {
    if ( segment >= SEGMENT_BARREL_NUM ) return false;
    if ( layer >= LAYER_BARREL_NUM ) return false;
    if ( channel >= CHANNEL_BARREL_LAYER_NUM[layer] ) return false;
  }
  return true;
}
 
//----------------------------------------------------------------------------
bool MucID::is_barrel( const Identifier& id ) {
  unsigned int pos = ( id.get_value() & MucID::BARREL_EC_MASK ) >> MucID::BARREL_EC_INDEX;
  return ( pos == 0 || pos == BARREL_EC_NUM - 1 ) ? false : true;
}
 
//----------------------------------------------------------------------------
int MucID::barrel_ec( const Identifier& id ) {
  return ( ( id.get_value() & MucID::BARREL_EC_MASK ) >> MucID::BARREL_EC_INDEX );
}
 
//----------------------------------------------------------------------------
int MucID::part( const Identifier& id ) {
  return ( ( id.get_value() & MucID::BARREL_EC_MASK ) >> MucID::BARREL_EC_INDEX );
}
 
//----------------------------------------------------------------------------
int MucID::segment( const Identifier& id ) {
  return ( id.get_value() & MucID::SEGMENT_MASK ) >> MucID::SEGMENT_INDEX;
}
 
//----------------------------------------------------------------------------
int MucID::seg( const Identifier& id ) {
  return ( id.get_value() & MucID::SEGMENT_MASK ) >> MucID::SEGMENT_INDEX;
}
 
//----------------------------------------------------------------------------
int MucID::layer( const Identifier& id ) {
  return ( id.get_value() & MucID::LAYER_MASK ) >> MucID::LAYER_INDEX;
}
 
//----------------------------------------------------------------------------
int MucID::gap( const Identifier& id ) {
  return ( id.get_value() & MucID::LAYER_MASK ) >> MucID::LAYER_INDEX;
}
 
//----------------------------------------------------------------------------
int MucID::channel( const Identifier& id ) {
  return ( id.get_value() & MucID::CHANNEL_MASK ) >> MucID::CHANNEL_INDEX;
}
 
//----------------------------------------------------------------------------
int MucID::strip( const Identifier& id ) {
  return ( id.get_value() & MucID::CHANNEL_MASK ) >> MucID::CHANNEL_INDEX;
}
 
//----------------------------------------------------------------------------
int MucID::segment_max( const Identifier& id ) {
  if ( is_barrel( id ) ) { return SEGMENT_BARREL_NUM - 1; }
  else { return SEGMENT_ENDCAP_NUM - 1; }
}
 
//----------------------------------------------------------------------------
int MucID::getSegNum( const Identifier& id ) {
  if ( is_barrel( id ) ) { return SEGMENT_BARREL_NUM; }
  else { return SEGMENT_ENDCAP_NUM; }
}
 
//----------------------------------------------------------------------------
int MucID::layer_max( const Identifier& id ) {
  if ( this->is_barrel( id ) ) { return LAYER_BARREL_NUM - 1; }
  else { return LAYER_ENDCAP_NUM - 1; }
}
 
//----------------------------------------------------------------------------
int MucID::getGapNum( const Identifier& id ) {
  if ( this->is_barrel( id ) ) { return LAYER_BARREL_NUM; }
  else { return LAYER_ENDCAP_NUM; }
}
 
//----------------------------------------------------------------------------
int MucID::channel_max( const Identifier& id ) {
  if ( this->is_barrel( id ) ) { return CHANNEL_BARREL_NUM_MAX - 1; }
  else { return CHANNEL_ENDCAP_NUM_MAX - 1; }
}
 
//----------------------------------------------------------------------------
int MucID::getStripNum( const Identifier& id ) {
  if ( this->is_barrel( id ) ) { return CHANNEL_BARREL_LAYER_NUM[this->gap( id )]; }
  else { return CHANNEL_ENDCAP_NUM_MAX; }
}
 
//----------------------------------------------------------------------------
Identifier MucID::channel_id( int barrel_ec, int segment, int layer, int channel ) {
  assert( values_ok( barrel_ec, segment, layer, channel ) );
  value_type value = ( MUC_ID << MUC_INDEX ) | ( barrel_ec << BARREL_EC_INDEX ) |
                     ( segment << SEGMENT_INDEX ) | ( layer << LAYER_INDEX ) |
                     ( channel << CHANNEL_INDEX );
  return Identifier( value );
}
 
//----------------------------------------------------------------------------
unsigned int MucID::getIntID( int barrel_ec, int segment, int layer, int channel ) {
  value_type value = ( MUC_ID << MUC_INDEX ) | ( barrel_ec << BARREL_EC_INDEX ) |
                     ( segment << SEGMENT_INDEX ) | ( layer << LAYER_INDEX ) |
                     ( channel << CHANNEL_INDEX );
  return value;
}
 
//---------------------------------------------------------------------------
unsigned int MucID::getPartNum() { return BARREL_EC_NUM; }
 
///---------------------------------------------------------------------------
unsigned int MucID::getSegNum( int part ) {
  if ( part == 1 ) return SEGMENT_BARREL_NUM;
  else if ( part == 0 || part == 2 ) return SEGMENT_ENDCAP_NUM;
  else return 0;
}
 
//----------------------------------------------------------------------------
unsigned int MucID::getGapNum( int part ) {
  if ( part == 1 ) return LAYER_BARREL_NUM;
  if ( part == 0 || part == 2 ) return LAYER_ENDCAP_NUM;
  else return 0;
}
 
//----------------------------------------------------------------------------
unsigned int MucID::getStripNum( int part, int seg, int gap ) {
  if ( part == 1 )
  {
    if ( seg == 2 ) return CHANNEL_BARREL_LAYER_NUM[gap];
    else return CHANNEL_BARREL_LAYER_NUM[gap];
  }
  else { return CHANNEL_ENDCAP_NUM_MAX; }
}
 
///---------------------------------------------------------------------------
unsigned int MucID::getSegMax() {
  if ( SEGMENT_BARREL_NUM > SEGMENT_ENDCAP_NUM ) return SEGMENT_BARREL_NUM;
  else return SEGMENT_ENDCAP_NUM;
}
 
///---------------------------------------------------------------------------
 
unsigned int MucID::getGapMax() {
  if ( LAYER_BARREL_NUM > LAYER_ENDCAP_NUM ) return LAYER_BARREL_NUM;
  else return LAYER_ENDCAP_NUM;
}
 
unsigned int MucID::getStripMax() {
  if ( CHANNEL_BARREL_NUM_MAX > CHANNEL_ENDCAP_NUM_MAX ) return CHANNEL_BARREL_NUM_MAX;
  else return CHANNEL_ENDCAP_NUM_MAX;
}
 
//---------------------------------------------------------------------------
unsigned int MucID::getSEGMENT_BARREL_MAX() { return SEGMENT_BARREL_NUM - 1; }
 
//---------------------------------------------------------------------------
unsigned int MucID::getSEGMENT_ENDCAP_MAX() { return SEGMENT_ENDCAP_NUM - 1; }
 
//---------------------------------------------------------------------------
unsigned int MucID::getLAYER_BARREL_MAX() { return LAYER_BARREL_NUM - 1; }
 
//---------------------------------------------------------------------------
unsigned int MucID::getLAYER_ENDCAP_MAX() { return LAYER_ENDCAP_NUM - 1; }
 
//---------------------------------------------------------------------------
unsigned int MucID::getCHANNEL_BARREL_MAX() { return CHANNEL_BARREL_NUM_MAX; }
 
//---------------------------------------------------------------------------
unsigned int MucID::getCHANNEL_ENDCAP_MAX() { return CHANNEL_ENDCAP_NUM_MAX; }
 
//---------------------------------------------------------------------------
unsigned int MucID::getBARREL_EC_MAX() { return BARREL_EC_NUM - 1; }
 
//---------------------------------------------------------------------------
unsigned int MucID::getBARREL_EC_MIN() { return 0; }