EventType Class Reference

#include <EventType.h>

Public Types
typedef std::vector< bool >	BitMask
typedef BitMask::const_iterator	BitMaskIterator
typedef BitMask::size_type	EventTypeCode
typedef std::pair< std::string, std::string >	NameTagPair
typedef std::vector< NameTagPair >	NameTagPairVec

Public Member Functions
	EventType ()
virtual	~EventType ()
void	add_type (EventTypeCode type_code)
void	set_user_type (const std::string &user_type)
void	set_detdescr_tags (const NameTagPairVec &pairs)
bool	test (EventTypeCode type_code) const
const std::string &	user_type (void) const
void	get_detdescr_tags (NameTagPairVec &pairs)
BitMaskIterator	bit_mask_begin (void) const
BitMaskIterator	bit_mask_end (void) const

Static Public Attributes
static const EventTypeCode	IS_SIMULATION = 0
static const EventTypeCode	IS_TESTBEAM = 1
static const EventTypeCode	IS_CALIBRATION = 2

Detailed Description

class EventType

This class represents the "type of event" where the type is given by one or more "characteristics".

Standard characteristics:

IS_SIMULATION  // false means IS_DATA
IS_TESTBEAM    // false means IS_FROM_ATLAS_DET
IS_CALIBRATION // false means IS_PHYSICS

Since an event may have MORE than one characteristic, a testbeam simulation event would respond true to first two of the above characteristics, whereas an offline simulation event would respond true to ONLY IS_SIMULATION.

These are set with:

void add_type (EventTypeCode type_code);

where the possible EventTypeCode's are provided as constants, e.g.:

static const EventTypeCode IS_SIMULATION;

Thus, one would set IS_SIMULATION by:

an_event_type.set_type_bit(EventType::IS_SIMULATION);

User-defined characteristics:

There is a possible to set and get a "user-defined" characteristic in terms of a string:

void add_type (const string& user_type); const string& user_type (void) const;

Access to the full set of characteristics:

This is possible via:

BitMaskIterator bit_mask_begin (void) const; BitMaskIterator bit_mask_end (void) const;

Implementation details:

The full set of characteristics is provided by static constants. One may add new event characteristics BOTH by adding more static constants AND by providing the cooresponding new boolean methods.

Definition at line 84 of file EventType.h.

Member Typedef Documentation

BitMask

std::vector<bool> EventType::BitMask

Definition at line 88 of file EventType.h.

BitMaskIterator

BitMask::const_iterator EventType::BitMaskIterator

Definition at line 89 of file EventType.h.

EventTypeCode

BitMask::size_type EventType::EventTypeCode

Definition at line 90 of file EventType.h.

NameTagPair

std::pair<std::string,std::string> EventType::NameTagPair

Definition at line 91 of file EventType.h.

NameTagPairVec

std::vector<NameTagPair> EventType::NameTagPairVec

Definition at line 92 of file EventType.h.

Constructor & Destructor Documentation

EventType()

EventType::EventType

(

)

Definition at line 29 of file EventType.cxx.

{}

~EventType()

EventType::~EventType ( )

virtual

Definition at line 33 of file EventType.cxx.

{}

Member Function Documentation

add_type()

void EventType::add_type

(

EventTypeCode

type_code

)

Definition at line 38 of file EventType.cxx.

{
    if(m_bit_mask.size() <= type_code) m_bit_mask.resize(type_code + 1, false);
    m_bit_mask[type_code] = true;
}

bit_mask_begin()

EventType::BitMaskIterator EventType::bit_mask_begin

(

void

)

const

Definition at line 135 of file EventType.cxx.

{
    return m_bit_mask.begin();
}

bit_mask_end()

EventType::BitMaskIterator EventType::bit_mask_end

(

void

)

const

Definition at line 141 of file EventType.cxx.

{
    return m_bit_mask.end();
}

get_detdescr_tags()

void EventType::get_detdescr_tags

(

NameTagPairVec &

pairs

)

Definition at line 93 of file EventType.cxx.

{
    // 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);
}

set_detdescr_tags()

void EventType::set_detdescr_tags

(

const NameTagPairVec &

pairs

)

Definition at line 51 of file EventType.cxx.

{
    // 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;
    }
}

set_user_type()

void EventType::set_user_type

(

const std::string &

user_type

)

Definition at line 45 of file EventType.cxx.

{
    m_user_type = user_type;
}

test()

bool EventType::test

(

EventTypeCode

type_code

)

const

Definition at line 70 of file EventType.cxx.

{
    if (m_bit_mask.size() <= type_code) return false;
    return m_bit_mask[type_code];
}

user_type()

const std::string & EventType::user_type

(

void

)

const

Definition at line 77 of file EventType.cxx.

{
    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;
}

Referenced by set_detdescr_tags(), set_user_type(), and user_type().

Member Data Documentation

IS_CALIBRATION

const EventType::EventTypeCode EventType::IS_CALIBRATION = 2

static

Definition at line 115 of file EventType.h.

IS_SIMULATION

const EventType::EventTypeCode EventType::IS_SIMULATION = 0

static

Definition at line 113 of file EventType.h.

IS_TESTBEAM

const EventType::EventTypeCode EventType::IS_TESTBEAM = 1

static

Definition at line 114 of file EventType.h.

---

The documentation for this class was generated from the following files:

• EventType.h
• EventType.cxx