HltID.cxx

Go to the documentation of this file.

#include "Identifier/HltID.h"
#include <assert.h>
#include <stdint.h>
 
HltID::HltID(void) {
}
 
HltID::~HltID(void) {
}
 
//----------------------------------------------------------------------------
Identifier HltID::convert(const unsigned int id,const int nmdc,const int ntof,const int nemc,const int nmuc) {
  uint32_t subid=id&(HltID::DETECTOR_MASK|HltID::ID_SUB_MASK);
 
  if(subid<=getID_HLT_MAX()) return data_type_id(HLT,subid);
 
  subid = subid - getID_HLT_MAX();
  if(subid<=nmdc)  return data_type_id(MDC,subid-1);
 
  subid = subid - nmdc;
  if(subid<=ntof)  return data_type_id(TOF,subid-1);
 
  subid = subid - ntof;
  if(subid<=nemc)  return data_type_id(EMC,subid-1);
 
  subid = subid - nemc;
  if(subid<=nmuc)  return data_type_id(MUC,subid-1);
  
  subid = subid - nmuc;
  return data_type_id(CON,subid-1);
}
 
//----------------------------------------------------------------------------
bool HltID::values_ok (const unsigned int detector,const unsigned int id_in_sub) {
  // Check values
  // unsigned int >= 0, this is definitely true.
  // Omit the compare with MIN(0) to avoid warnings in compile.
  switch(detector)
    {
    case HLT:
      if ( id_in_sub  > ID_HLT_MAX  )  return false;
      break;
    case MDC:
      if ( id_in_sub  > ID_MDC_MAX  )  return false;
      break;
    case TOF:
      if ( id_in_sub  > ID_TOF_MAX  )  return false;
      break;
    case EMC:
      if ( id_in_sub  > ID_EMC_MAX  )  return false;
      break;
    case MUC:
      if ( id_in_sub  > ID_MUC_MAX  )  return false;
      break;
    case CON:
      return true;
      break;
    default:
      return false;
      break;
    }
    
  return true;
}
 
//----------------------------------------------------------------------------
bool  HltID::is_ef_result (const Identifier& id) {
   unsigned int pos = (id.get_value() & HltID::DETECTOR_MASK) >>  HltID::DETECTOR_INDEX;
   return (pos == HLT) ? true : false ;
}
 
bool  HltID::is_eventtype (const Identifier& id) {
   unsigned int pos = (id.get_value() & HltID::DETECTOR_MASK) >>  HltID::DETECTOR_INDEX;
   unsigned int no  = (id.get_value() & HltID::ID_SUB_MASK) >>  HltID::ID_SUB_INDEX;
   return ((pos == HLT)&&(no==EVENTTYPE)) ? true : false ;
}
 
bool  HltID::is_algorithm (const Identifier& id) {
   unsigned int pos = (id.get_value() & HltID::DETECTOR_MASK) >>  HltID::DETECTOR_INDEX;
   unsigned int no  = (id.get_value() & HltID::ID_SUB_MASK) >>  HltID::ID_SUB_INDEX;
   return ((pos == HLT)&&(no==ALGORITHM)) ? true : false ;
}
 
bool  HltID::is_criteria (const Identifier& id) {
   unsigned int pos = (id.get_value() & HltID::DETECTOR_MASK) >>  HltID::DETECTOR_INDEX;
   unsigned int no  = (id.get_value() & HltID::ID_SUB_MASK) >>  HltID::ID_SUB_INDEX;
   return ((pos == HLT)&&(no==CRITERIA)) ? true : false ;
}
 
bool  HltID::is_version (const Identifier& id) {
   unsigned int pos = (id.get_value() & HltID::DETECTOR_MASK) >>  HltID::DETECTOR_INDEX;
   unsigned int no  = (id.get_value() & HltID::ID_SUB_MASK) >>  HltID::ID_SUB_INDEX;
   return ((pos == HLT)&&(no==VERSION)) ? true : false ;
}
 
bool  HltID::is_energy (const Identifier& id) {
   unsigned int pos = (id.get_value() & HltID::DETECTOR_MASK) >>  HltID::DETECTOR_INDEX;
   unsigned int no  = (id.get_value() & HltID::ID_SUB_MASK) >>  HltID::ID_SUB_INDEX;
   return ((pos == HLT)&&(no==ENERGY)) ? true : false ;
}
 
bool  HltID::is_number (const Identifier& id) {
  unsigned int pos = (id.get_value() & HltID::DETECTOR_MASK) >>  HltID::DETECTOR_INDEX;
  unsigned int no  = (id.get_value() & HltID::ID_SUB_MASK) >>  HltID::ID_SUB_INDEX;
  return ((pos == HLT)&&(no==NUMSUB)) ? true : false ;
}
 
bool  HltID::is_ncon (const Identifier& id) {
  unsigned int pos = (id.get_value() & HltID::DETECTOR_MASK) >>  HltID::DETECTOR_INDEX;
  unsigned int no  = (id.get_value() & HltID::ID_SUB_MASK) >>  HltID::ID_SUB_INDEX;
  return ((pos == CON)&&(no==NUMCON)) ? true : false ;
}
 
bool  HltID::is_mdc_inf (const Identifier& id) {
   unsigned int pos = (id.get_value() & HltID::DETECTOR_MASK) >>  HltID::DETECTOR_INDEX;
   return (pos == MDC) ? true : false ;
}
 
bool  HltID::is_tof_inf (const Identifier& id) {
   unsigned int pos = (id.get_value() & HltID::DETECTOR_MASK) >>  HltID::DETECTOR_INDEX;
   return (pos == TOF) ? true : false ;
}
 
bool  HltID::is_emc_inf (const Identifier& id) {
   unsigned int pos = (id.get_value() & HltID::DETECTOR_MASK) >>  HltID::DETECTOR_INDEX;
   return (pos == EMC) ? true : false ;
}
 
bool  HltID::is_muc_inf (const Identifier& id) {
   unsigned int pos = (id.get_value() & HltID::DETECTOR_MASK) >>  HltID::DETECTOR_INDEX;
   return (pos == MUC) ? true : false ;
}
 
bool  HltID::is_con_inf (const Identifier& id) {
  unsigned int pos = (id.get_value() & HltID::DETECTOR_MASK) >>  HltID::DETECTOR_INDEX;
  return (pos == CON) ? true : false ;
}
 
//----------------------------------------------------------------------------
unsigned int HltID::detector (const Identifier& id) {
   return ((id.get_value() & HltID::DETECTOR_MASK) >>  HltID::DETECTOR_INDEX);  
}
 
//----------------------------------------------------------------------------
unsigned int HltID::id_sub (const Identifier& id) {
  return (id.get_value() & HltID::ID_SUB_MASK) >>  HltID::ID_SUB_INDEX;  
}
 
//----------------------------------------------------------------------------
unsigned int HltID::id_sub_max (const Identifier& id) {
  if (is_ef_result(id)) {
    return ID_HLT_MAX;
  }
  else if (is_mdc_inf(id)) {
    return ID_MDC_MAX;
  }
  else if (is_tof_inf(id)) {
    return ID_TOF_MAX;
  }
  else if (is_emc_inf(id)) {
    return ID_EMC_MAX;
  }
  else if (is_muc_inf(id)) {
    return ID_MUC_MAX;
  }
  else {
    return 0;
  }
}
 
//----------------------------------------------------------------------------
Identifier HltID::data_type_id(const unsigned int detector,const unsigned int id_in_sub){
  assert ( values_ok(detector, id_in_sub) );
  //if(!values_ok(detector, id_in_sub)) return Identifier(0);
 
  unsigned int value = (HLT_ID << HLT_INDEX) | (detector << DETECTOR_INDEX)|
     (id_in_sub<< ID_SUB_INDEX);
  return Identifier(value); 
}
 
unsigned int HltID::getIntID (const unsigned int detector,const unsigned int id_in_sub){
  assert ( values_ok(detector, id_in_sub) );
  //if(!values_ok(detector, id_in_sub)) return 0;
 
  unsigned int value = (HLT_ID << HLT_INDEX) | (detector << DETECTOR_INDEX)|
     (id_in_sub<< ID_SUB_INDEX);
  return value;
}