#include <CompareMuonSegmentKeys.h>

Collaboration diagram for Muon::CompareMuonSegmentKeys:

Public Types
enum	OverlapResult { Identical = 0 , SubSet = 1 , SuperSet = 2 , PartialOverlap = 3 , NoOverlap = 4 , Unknown = 5 }
	enum for the overlap result More...

Public Member Functions
OverlapResult	operator() (const MuonSegmentKey &sk1, const MuonSegmentKey &sk2, bool ignoreTriggerHits=false)
	calculate overlap between two SegmentKey2s, if ignoreTriggerHits == true trigger hits will not be included in the comparison, returns an OverlapResult
std::string	print (const OverlapResult &result) const
	print result to string

Public Attributes
unsigned int	intersectionSize
unsigned int	segment1Size
unsigned int	segment2Size
unsigned int	segment1SizeTrigger
unsigned int	segment2SizeTrigger
unsigned int	intersectionSizeTrigger

Detailed Description

Definition at line 14 of file CompareMuonSegmentKeys.h.

Member Enumeration Documentation

◆ OverlapResult

enum Muon::CompareMuonSegmentKeys::OverlapResult

enum for the overlap result

Enumerator
Identical
SubSet
SuperSet
PartialOverlap
NoOverlap
Unknown

Definition at line 16 of file CompareMuonSegmentKeys.h.

                           {
            Identical = 0,       //<! segments are identical
            SubSet = 1,          //<! the first segment is a subset of the second
            SuperSet = 2,        //<! the first segment is a superset of the second
            PartialOverlap = 3,  //<! some hits of the segment overlap
            NoOverlap = 4,       //<! there is no overlap between the segments
            Unknown = 5          //<! unknown overlap tyep, this should not happen
        };

Member Function Documentation

◆ operator()()

Muon::CompareMuonSegmentKeys::OverlapResult Muon::CompareMuonSegmentKeys::operator()	(	const MuonSegmentKey &	sk1,
		const MuonSegmentKey &	sk2,
		bool	ignoreTriggerHits = false )

calculate overlap between two SegmentKey2s, if ignoreTriggerHits == true trigger hits will not be included in the comparison, returns an OverlapResult

Definition at line 14 of file CompareMuonSegmentKeys.cxx.

                                                                                                             {
    std::vector<std::pair<unsigned int, int> > intersection;
    std::set_intersection(sk1.keys().begin(), sk1.keys().end(), sk2.keys().begin(), sk2.keys().end(), std::back_inserter(intersection));
    intersectionSize = intersection.size();
    segment1Size = sk1.keys().size();
    segment2Size = sk2.keys().size();
 
    segment1SizeTrigger = sk1.keysTrigger().size();
    segment2SizeTrigger = sk2.keysTrigger().size();
    std::vector<std::pair<unsigned int, int> > intersectionTrig;
    std::set_intersection(sk1.keysTrigger().begin(), sk1.keysTrigger().end(), sk2.keysTrigger().begin(), sk2.keysTrigger().end(),
                          std::back_inserter(intersectionTrig));
    intersectionSizeTrigger = intersectionTrig.size();
 
    if (intersectionSize == 0) {
        if (segment1Size == 0 && segment2Size == 0) {
            if (segment1SizeTrigger == intersectionSizeTrigger) {
                // overlap between second segment and the intersection also includes all hits
                // the two segments share all hits
                if (segment2SizeTrigger == intersectionSizeTrigger) {
                    return Identical;
                } else if (segment1SizeTrigger > segment2SizeTrigger) {
                    return SuperSet;
                } else {
                    return SubSet;
                }
            } else if (segment2SizeTrigger == intersectionSizeTrigger) {
                if (segment1SizeTrigger > intersectionSizeTrigger) return SuperSet;
            } else {
                return PartialOverlap;
            }
        }
        return NoOverlap;
    } else {
        // overlap between first segment and the intersection includes all hits
        if (segment1Size == intersectionSize) {
            // overlap between second segment and the intersection also includes all hits
            // the two segments share all hits
            if (segment2Size == intersectionSize) {
                if (ignoreTriggerHits) return Identical;
 
                if (segment1SizeTrigger == intersectionSizeTrigger) {
                    // overlap between second segment and the intersection also includes all hits
                    // the two segments share all hits
                    if (segment2SizeTrigger == intersectionSizeTrigger) {
                        return Identical;
                    } else if (segment1SizeTrigger > segment2SizeTrigger) {
                        return SuperSet;
                    } else {
                        return SubSet;
                    }
                } else if (segment2SizeTrigger == intersectionSizeTrigger) {
                    if (segment1SizeTrigger > intersectionSizeTrigger) return SuperSet;
                } else {
                    return PartialOverlap;
                }
            } else if (segment2Size > intersectionSize) {
                return SubSet;
            }
        } else if (segment2Size == intersectionSize) {
            if (segment1Size > intersectionSize) {
                // the first segment has more hits and is better
                return SuperSet;
            }
        } else {
            return PartialOverlap;
        }
    }
    return Muon::CompareMuonSegmentKeys::Unknown;
}

◆ print()

std::string Muon::CompareMuonSegmentKeys::print ( const OverlapResult & result ) const

print result to string

Definition at line 87 of file CompareMuonSegmentKeys.cxx.

                                                                                                       {
    std::ostringstream sout;
 
    if (result == Identical)
        sout << "Identical";
    else if (result == SubSet)
        sout << "SubSet";
    else if (result == SuperSet)
        sout << "SuperSet";
    else if (result == PartialOverlap)
        sout << "PartialOverlap";
    else if (result == NoOverlap)
        sout << "NoOverlap";
    else if (result == Unknown)
        sout << "Unknown";
    else
        sout << "UnknownType";
    sout << " intersects (" << intersectionSize << "," << intersectionSizeTrigger << ") seg1 (" << segment1Size << ","
         << segment1SizeTrigger << ") "
         << " seg2 (" << segment2Size << "," << segment2SizeTrigger << ") ";
    return sout.str();
}

Member Data Documentation

◆ intersectionSize

unsigned int Muon::CompareMuonSegmentKeys::intersectionSize

Definition at line 32 of file CompareMuonSegmentKeys.h.

◆ intersectionSizeTrigger

unsigned int Muon::CompareMuonSegmentKeys::intersectionSizeTrigger

Definition at line 38 of file CompareMuonSegmentKeys.h.

◆ segment1Size

unsigned int Muon::CompareMuonSegmentKeys::segment1Size

Definition at line 33 of file CompareMuonSegmentKeys.h.

◆ segment1SizeTrigger

unsigned int Muon::CompareMuonSegmentKeys::segment1SizeTrigger

Definition at line 36 of file CompareMuonSegmentKeys.h.

◆ segment2Size

unsigned int Muon::CompareMuonSegmentKeys::segment2Size

Definition at line 34 of file CompareMuonSegmentKeys.h.

◆ segment2SizeTrigger

unsigned int Muon::CompareMuonSegmentKeys::segment2SizeTrigger

Definition at line 37 of file CompareMuonSegmentKeys.h.

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

Public Types

Public Member Functions

Public Attributes