EventType.cxx

Go to the documentation of this file.

/***************************************************************************
 Event Info Package
 -----------------------------------------
 Copyright (C) 2000 by ATLAS Collaboration
 ***************************************************************************/
 
 
//<<<<<< INCLUDES                                                       >>>>>>
 
#include "HltDataTypes/EventType.h"
 
//<<<<<< PRIVATE DEFINES                                                >>>>>>
//<<<<<< PRIVATE CONSTANTS                                              >>>>>>
//<<<<<< PRIVATE TYPES                                                  >>>>>>
//<<<<<< PRIVATE VARIABLE DEFINITIONS                                   >>>>>>
//<<<<<< PUBLIC VARIABLE DEFINITIONS                                    >>>>>>
//<<<<<< CLASS STRUCTURE INITIALIZATION                                 >>>>>>
//<<<<<< PRIVATE FUNCTION DEFINITIONS                                   >>>>>>
//<<<<<< PUBLIC FUNCTION DEFINITIONS                                    >>>>>>
//<<<<<< MEMBER FUNCTION DEFINITIONS                                    >>>>>>
 
// List of EventTypeCodes
//   To add on a new code, simply extend at the end 
const EventType::EventTypeCode  EventType::IS_SIMULATION        = 0;
const EventType::EventTypeCode  EventType::IS_TESTBEAM          = 1;
const EventType::EventTypeCode  EventType::IS_CALIBRATION       = 2;
 
 
EventType::EventType()
{}
 
 
EventType::~EventType()
{}
 
 
void        
EventType::add_type (EventTypeCode type_code)
{
    if(m_bit_mask.size() <= type_code) m_bit_mask.resize(type_code + 1, false);
    m_bit_mask[type_code] = true;
}
 
void        
EventType::set_user_type    (const std::string& user_type)
{
    m_user_type = user_type;
}
 
void                
EventType::set_detdescr_tags(const NameTagPairVec& pairs)
{
    // We must save in m_user_type the dd tags for the moment to avoid
    // schema evolution. Overwrite if existing "sep" is found.
 
    // Force overwrite:
    m_user_type = user_type(); 
 
    char sep = '#';
    for (unsigned int i = 0; i < pairs.size(); ++i) {
    m_user_type += sep;
    m_user_type += pairs[i].first;
    m_user_type += sep;
    m_user_type += pairs[i].second;
    }
}
 
 
bool        
EventType::test     (EventTypeCode type_code) const
{
    if (m_bit_mask.size() <= type_code) return false;
    return m_bit_mask[type_code];
}
 
const std::string&  
EventType::user_type    (void) const
{
    char sep = '#';
    std::string::size_type beg = m_user_type.find(sep);
    static std::string user_type;
    if (beg != std::string::npos) {
    user_type = m_user_type.substr(0, beg);
    }
    else {
    user_type = m_user_type;
    }
    return user_type;
}
 
 
void       
EventType::get_detdescr_tags(NameTagPairVec& pairs)
{
    // We must extract from m_user_type the dd tags for the moment to
    // avoid schema evolution.
 
    char sep = '#';
    bool done = false;
    std::string::size_type beg = m_user_type.find(sep);
    do {
    if (beg != std::string::npos) {
      std::string::size_type end1 = m_user_type.find(sep, beg+1);
        if (end1 != std::string::npos) {
          std::string::size_type end2 = m_user_type.find(sep, end1+1);
        if (end2 != std::string::npos) {
            // end2 is a new separator
            std::string first  = m_user_type.substr(beg+1, end1-beg-1);
            std::string second = m_user_type.substr(end1+1, end2-end1-1);
            pairs.push_back(NameTagPair(first,second));
 
            // continue with new beg
            beg = end2;
        }
        else {
            // end2 is the end of the string
            std::string first  = m_user_type.substr(beg+1, end1-beg-1);
            std::string second = m_user_type.substr(end1+1, m_user_type.size()-1);
            pairs.push_back(NameTagPair(first,second));
            done = true; // finished
        }
        }
        else {
        done = true; // finished
        }
    }
    else {
        done = true; // finished
    }
    } while (!done);
}
 
 
EventType::BitMaskIterator  
EventType::bit_mask_begin   (void) const
{
    return m_bit_mask.begin();
}
 
EventType::BitMaskIterator  
EventType::bit_mask_end     (void) const
{
    return m_bit_mask.end();
}