Muon::MuonTrackSteeringStrategy Class Reference

#include <MuonTrackSteeringStrategy.h>

Collaboration diagram for Muon::MuonTrackSteeringStrategy:

Public Types
enum	Option {   CutSeedsOnTracks = 0x0, CombineSegInStation = 0x1, DynamicSeeding = 0x2, PreferOutsideIn = 0x3,   AllowOneSharedHit = 0x4, DoRefinement = 0x5, DoAmbiSolving = 0x6, BarrelEndcapFilter = 0x7,   Last = 0x8 }

Public Member Functions
	MuonTrackSteeringStrategy (const std::string &name, const std::bitset< Last > &bits, std::vector< std::vector< MuonStationIndex::ChIndex > > &path, std::vector< unsigned int > &seedOrder)
	MuonTrackSteeringStrategy (const std::string &name, std::vector< std::string > &options, std::vector< std::vector< MuonStationIndex::ChIndex > > &path)
	Constructor that assumes the seed order could come as part of the options. More...
	MuonTrackSteeringStrategy (const std::string &name, std::vector< std::string > &options, std::vector< std::vector< MuonStationIndex::ChIndex > > &path, std::vector< unsigned int > &seedOrder)
void	setOption (Option, bool value)
void	setOption (const std::string &, bool value)
bool	option (Option) const
std::bitset< Last >	allOptions () const
void	setCh (const std::vector< MuonStationIndex::ChIndex > &val, const unsigned int layer)
void	setCh (const std::vector< std::vector< MuonStationIndex::ChIndex > > &val)
const std::vector< std::vector< MuonStationIndex::ChIndex > > &	getAll () const
const std::vector< MuonStationIndex::ChIndex > &	getCh (const unsigned int) const
const std::string	getName () const
void	setName (const std::string &name)
const std::vector< unsigned int > &	seeds () const
void	setSeeds (const std::vector< unsigned int > &val)

Private Attributes
std::string	m_name
std::bitset< Last >	m_bits
	List of all of the options available. More...
std::vector< std::vector< MuonStationIndex::ChIndex > >	m_path
std::vector< unsigned int >	m_seeds

Detailed Description

Definition at line 17 of file MuonTrackSteeringStrategy.h.

Member Enumeration Documentation

Option

enum Muon::MuonTrackSteeringStrategy::Option

Enumerator
CutSeedsOnTracks
CombineSegInStation
DynamicSeeding
PreferOutsideIn
AllowOneSharedHit
DoRefinement
DoAmbiSolving
BarrelEndcapFilter
Last

Definition at line 19 of file MuonTrackSteeringStrategy.h.

                    {
            CutSeedsOnTracks = 0x0,
            CombineSegInStation = 0x1,
            DynamicSeeding = 0x2,
            PreferOutsideIn = 0x3,
            AllowOneSharedHit = 0x4,
            DoRefinement = 0x5,
            DoAmbiSolving = 0x6,
            BarrelEndcapFilter = 0x7,
            Last = 0x8
        };

Constructor & Destructor Documentation

MuonTrackSteeringStrategy() [1/3]

Muon::MuonTrackSteeringStrategy::MuonTrackSteeringStrategy ( const std::string &  name, const std::bitset< Last > &  bits, std::vector< std::vector< MuonStationIndex::ChIndex > > &  path, std::vector< unsigned int > &  seedOrder  )

inline

Definition at line 31 of file MuonTrackSteeringStrategy.h.

                                                                                                                            :
            m_name(name), m_bits(bits), m_path(path), m_seeds(seedOrder) {}

MuonTrackSteeringStrategy() [2/3]

Muon::MuonTrackSteeringStrategy::MuonTrackSteeringStrategy ( const std::string &  name, std::vector< std::string > &  options, std::vector< std::vector< MuonStationIndex::ChIndex > > &  path  )

inline

Constructor that assumes the seed order could come as part of the options.

Definition at line 36 of file MuonTrackSteeringStrategy.h.

                                                                                        :
            m_name(name), m_path(path) {
            for (unsigned int i = 0; i < Last; ++i) m_bits.set(i, 0);
            for (unsigned int i = 0; i < options.size(); ++i) setOption(options[i], true);
        }

MuonTrackSteeringStrategy() [3/3]

Muon::MuonTrackSteeringStrategy::MuonTrackSteeringStrategy ( const std::string &  name, std::vector< std::string > &  options, std::vector< std::vector< MuonStationIndex::ChIndex > > &  path, std::vector< unsigned int > &  seedOrder  )

inline

Definition at line 43 of file MuonTrackSteeringStrategy.h.

                                                                                                                            :
            m_name(name), m_path(path), m_seeds(seedOrder) {
            for (unsigned int i = 0; i < Last; ++i) m_bits.set(i, 0);
            for (unsigned int i = 0; i < options.size(); ++i) setOption(options[i], true);
        }

Member Function Documentation

allOptions()

std::bitset<Last> Muon::MuonTrackSteeringStrategy::allOptions ( ) const

inline

Definition at line 53 of file MuonTrackSteeringStrategy.h.

{ return m_bits; }

getAll()

const std::vector<std::vector<MuonStationIndex::ChIndex> >& Muon::MuonTrackSteeringStrategy::getAll ( ) const

inline

Definition at line 60 of file MuonTrackSteeringStrategy.h.

{ return m_path; }

getCh()

const std::vector< Muon::MuonStationIndex::ChIndex > & Muon::MuonTrackSteeringStrategy::getCh ( const unsigned int  layer = 0 ) const

inline

Definition at line 124 of file MuonTrackSteeringStrategy.h.

                                                                                                                            {
    if (layer >= m_path.size()) {
        throw std::range_error("MuonTrackSteering a path beyond the possible paths is chosen");
    }
    return m_path[layer];
}

getName()

const std::string Muon::MuonTrackSteeringStrategy::getName ( ) const

inline

Definition at line 64 of file MuonTrackSteeringStrategy.h.

{ return m_name; }

option()

bool Muon::MuonTrackSteeringStrategy::option ( Option  op ) const

inline

Definition at line 131 of file MuonTrackSteeringStrategy.h.

                                                                                              {
    return m_bits[static_cast<unsigned int>(op)];
}

seeds()

const std::vector<unsigned int>& Muon::MuonTrackSteeringStrategy::seeds ( ) const

inline

Definition at line 67 of file MuonTrackSteeringStrategy.h.

{ return m_seeds; }

setCh() [1/2]

void Muon::MuonTrackSteeringStrategy::setCh ( const std::vector< MuonStationIndex::ChIndex > &  val, const unsigned int  layer  )

inline

Definition at line 115 of file MuonTrackSteeringStrategy.h.

                                                                                                                        {
    if (layer < m_path.size())
        m_path[layer] = val;
    else {  // assume the user knows what he or she is doing
        m_path.resize(layer + 1);
        m_path[layer] = val;
    }
}

setCh() [2/2]

void Muon::MuonTrackSteeringStrategy::setCh ( const std::vector< std::vector< MuonStationIndex::ChIndex > > &  val )

inline

Definition at line 57 of file MuonTrackSteeringStrategy.h.

{ m_path = val; }

setName()

void Muon::MuonTrackSteeringStrategy::setName ( const std::string &  name )

inline

Definition at line 65 of file MuonTrackSteeringStrategy.h.

{ m_name = name; }

setOption() [1/2]

void Muon::MuonTrackSteeringStrategy::setOption ( const std::string &  opt, bool  value  )

inline

Definition at line 78 of file MuonTrackSteeringStrategy.h.

                                                                                     {
    if (opt == "CutSeedsOnTracks")
        setOption(CutSeedsOnTracks, value);
    else if (opt == "CombineSegInStation")
        setOption(CombineSegInStation, value);
    else if (opt == "DynamicSeeding")
        setOption(DynamicSeeding, value);
    else if (opt == "PreferOutsideIn")
        setOption(PreferOutsideIn, value);
    else if (opt == "AllowOneSharedHit")
        setOption(AllowOneSharedHit, value);
    else if (opt == "DoRefinement")
        setOption(DoRefinement, value);
    else if (opt == "DoAmbiSolving")
        setOption(DoAmbiSolving, value);
    else if (opt == "BarrelEndcapFilter")
        setOption(BarrelEndcapFilter, value);
    else {
        // Attempt to interpret the string as a seed sequence
        std::vector<unsigned int> seeds;
        bool success = true;
        for (unsigned int i = 0; i < opt.size() && success; ++i) {
            int holder = int(opt[i]) - 48;
            if (holder < 0 || holder > 9)
                success = false;
            else
                seeds.push_back(holder);
        }
        if (success) setSeeds(seeds);
    }
}

setOption() [2/2]

void Muon::MuonTrackSteeringStrategy::setOption ( Option  opt, bool  value  )

inline

Definition at line 110 of file MuonTrackSteeringStrategy.h.

                                                                                 {
    if (opt == Last) return;
    m_bits[opt] = value;
}

setSeeds()

void Muon::MuonTrackSteeringStrategy::setSeeds ( const std::vector< unsigned int > &  val )

inline

Definition at line 68 of file MuonTrackSteeringStrategy.h.

{ m_seeds = val; }

Member Data Documentation

m_bits

std::bitset<Last> Muon::MuonTrackSteeringStrategy::m_bits

private

List of all of the options available.

Definition at line 72 of file MuonTrackSteeringStrategy.h.

m_name

std::string Muon::MuonTrackSteeringStrategy::m_name

private

Definition at line 71 of file MuonTrackSteeringStrategy.h.

m_path

std::vector<std::vector<MuonStationIndex::ChIndex> > Muon::MuonTrackSteeringStrategy::m_path

private

Definition at line 73 of file MuonTrackSteeringStrategy.h.

m_seeds

std::vector<unsigned int> Muon::MuonTrackSteeringStrategy::m_seeds

private

Definition at line 74 of file MuonTrackSteeringStrategy.h.

---

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

• MuonTrackSteeringStrategy.h