Muon::MuonSectorMapping Class Reference

#include <MuonSectorMapping.h>

Collaboration diagram for Muon::MuonSectorMapping:

Public Member Functions
bool	insideSector (int sector, double phi) const
	checks whether the phi position is consistent with sector
int	getSector (double phi) const
	returns the sector corresponding to the phi position
void	getSectors (double phi, std::vector< int > &sectors) const
	returns the main sector plus neighboring if the phi position is in an overlap region
double	sectorPhi (int sector) const
	returns the centeral phi position of a sector in radians
double	transformPhiToSector (double phi, int sector, bool toSector=true) const
	transforms a phi position from and to the sector coordinate system in radians
double	transformRToSector (double r, double phi, int sector, bool toSector=true) const
	expresses a radial position from and to the sector coordinate frame, the phi position should always be global in mm
double	sectorOverlapPhi (int sector1, int sector2) const
	returns the phi position of the overlap between the two sectors (which have to be neighboring) in radians
bool	closeToSectorBoundary (double phi) const
	checks whether the phi position is close to a sector boundary
double	transformRToNeighboringSector (double r, int sectorHit, int sectorTarget) const
	transform a radial position from one sector frame into another
double	sectorSize (int sector) const
	sector size (exclusive) in radians
double	sectorWidth (int sector) const
	sector width (with overlap) in radians

Static Public Member Functions
static bool	isSmall (int sector)

Static Private Attributes
static constexpr double	s_oneEightsOfPi {M_PI / 8.}
static constexpr double	s_inverseOneEightsOfPi {8. / M_PI}
static constexpr std::array< double, 2 >	s_sectorSize {0.4 * s_oneEightsOfPi, 0.6 * s_oneEightsOfPi}
static constexpr double	s_sectorOverlap {0.1 * s_oneEightsOfPi}
static bool s_debug	ATLAS_THREAD_SAFE

Detailed Description

Definition at line 20 of file MuonSectorMapping.h.

Member Function Documentation

closeToSectorBoundary()

bool Muon::MuonSectorMapping::closeToSectorBoundary ( double phi ) const

inline

checks whether the phi position is close to a sector boundary

Definition at line 106 of file MuonSectorMapping.h.

                                                                         {
        std::vector<int> sectors;
        getSectors(phi, sectors);
        return sectors.size() > 1;
    }

getSector()

int Muon::MuonSectorMapping::getSector ( double phi ) const

inline

returns the sector corresponding to the phi position

Definition at line 86 of file MuonSectorMapping.h.

                                                            {
        // remap phi onto sector structure
        double val = (phi + sectorSize(1)) * s_inverseOneEightsOfPi;  // convert to value between -8 and 8, shift by width first sector
        if (val < 0) val += 16;
        int sliceIndex = static_cast<int>(val / 2);  // large/small wedge
        double valueInSlice = val - 2 * sliceIndex;
        int sector = 2 * sliceIndex + 1;
        if (valueInSlice > 1.2) ++sector;
        return sector;
    }

getSectors()

void Muon::MuonSectorMapping::getSectors ( double phi, std::vector< int > & sectors ) const

inline

returns the main sector plus neighboring if the phi position is in an overlap region

Definition at line 97 of file MuonSectorMapping.h.

                                                                                       {
        int sector = getSector(phi);
        int sectorNext = sector != 16 ? sector + 1 : 1;
        int sectorBefore = sector != 1 ? sector - 1 : 16;
        if (insideSector(sectorBefore, phi)) sectors.push_back(sectorBefore);
        if (insideSector(sector, phi)) sectors.push_back(sector);
        if (insideSector(sectorNext, phi)) sectors.push_back(sectorNext);
    }

insideSector()

bool Muon::MuonSectorMapping::insideSector ( int sector, double phi ) const

inline

checks whether the phi position is consistent with sector

Definition at line 74 of file MuonSectorMapping.h.

                                                                            {
        double phiInSec = transformPhiToSector(phi, sector);
        if (phiInSec < -sectorWidth(sector)) return false;
        if (phiInSec > sectorWidth(sector)) return false;
        return true;
    }

isSmall()

bool Muon::MuonSectorMapping::isSmall ( int sector )

inlinestatic

Definition at line 34 of file MuonSectorMapping.h.

                                        {
            return sector % 2 == 0;
        }

sectorOverlapPhi()

double Muon::MuonSectorMapping::sectorOverlapPhi ( int sector1, int sector2 ) const

inline

returns the phi position of the overlap between the two sectors (which have to be neighboring) in radians

Definition at line 120 of file MuonSectorMapping.h.

                                                                                    {
        if (sector1 == sector2) return sectorPhi(sector1);
 
        int s1 = std::min(sector1, sector2);
        int s2 = std::max(sector1, sector2);
        if (s2 == 16 && s1 == 1) {
            s1 = 16;
            s2 = 1;
        } else if (std::abs(s1 - s2) > 1) {
            if (s_debug) std::cout << " bad sector combination: not neighbouring " << s1 << "   " << s2 << std::endl;
            return 0;
        }
 
        double phi1 = sectorPhi(s1);
        double phio1 = phi1 + sectorSize(s1);
        if (phio1 > M_PI) phio1 -= 2 * M_PI;
 
        return phio1;
    }

sectorPhi()

double Muon::MuonSectorMapping::sectorPhi ( int sector ) const

inline

returns the centeral phi position of a sector in radians

Definition at line 81 of file MuonSectorMapping.h.

                                                               {
        if (sector < 10) return M_PI * (sector - 1) / 8.;
        return -M_PI * (2 - (sector - 1) / 8.);
    }

sectorSize()

double Muon::MuonSectorMapping::sectorSize ( int sector ) const

inline

sector size (exclusive) in radians

Definition at line 67 of file MuonSectorMapping.h.

                                                                {
        const int idx = sector % 2;
        return s_sectorSize[idx];
    }

sectorWidth()

double Muon::MuonSectorMapping::sectorWidth ( int sector ) const

inline

sector width (with overlap) in radians

Definition at line 72 of file MuonSectorMapping.h.

{ return sectorSize(sector) + s_sectorOverlap; }

transformPhiToSector()

double Muon::MuonSectorMapping::transformPhiToSector ( double phi, int sector, bool toSector = true ) const

inline

transforms a phi position from and to the sector coordinate system in radians

Definition at line 112 of file MuonSectorMapping.h.

                                                                                                     {
        double sign = toSector ? -1 : 1;
        double dphi = phi + sign * sectorPhi(sector);
        if (dphi > M_PI) dphi -= 2 * M_PI;
        if (dphi < -M_PI) dphi += 2 * M_PI;
        return dphi;
    }

transformRToNeighboringSector()

double Muon::MuonSectorMapping::transformRToNeighboringSector ( double r, int sectorHit, int sectorTarget ) const

inline

transform a radial position from one sector frame into another

Definition at line 152 of file MuonSectorMapping.h.

                                                                                                            {
        double phi = sectorPhi(sectorHit);
        double phio = sectorOverlapPhi(sectorHit, sector);
        double dphio = phi - phio;
        if (dphio < -M_PI) dphio += 2 * M_PI;
        double redge = r / std::cos(dphio);
        double phi_sec = sectorPhi(sector);
        double dphi = phio - phi_sec;
        if (dphi < -M_PI) dphi += 2 * M_PI;
        if (std::abs(dphi) > 0.3 && s_debug) {
            std::cout << " large dphi detected!!: sector " << sector << " of hit " << sectorHit << " phi ref sector " << phi_sec << " hit "
                      << phi << " dphi " << dphi << std::endl;
        }
        return redge * std::cos(dphi);
    }

transformRToSector()

double Muon::MuonSectorMapping::transformRToSector ( double r, double phi, int sector, bool toSector = true ) const

inline

expresses a radial position from and to the sector coordinate frame, the phi position should always be global in mm

Definition at line 140 of file MuonSectorMapping.h.

                                                                                                             {
        double dphi = transformPhiToSector(phi, sector);
        if (std::abs(dphi) > 0.3 && s_debug) {
            std::cout << " large dphi detected!!: phi " << phi << " sector " << sector << " phi " << sectorPhi(sector) << " " << phi
                      << " dphi " << dphi << std::endl;
        }
        if (toSector)
            return r * std::cos(dphi);
        else
            return r / std::cos(dphi);
    }

Member Data Documentation

ATLAS_THREAD_SAFE

bool s_debug Muon::MuonSectorMapping::ATLAS_THREAD_SAFE

staticprivate

Definition at line 64 of file MuonSectorMapping.h.

s_inverseOneEightsOfPi

double Muon::MuonSectorMapping::s_inverseOneEightsOfPi {8. / M_PI}

staticconstexprprivate

Definition at line 61 of file MuonSectorMapping.h.

{8. / M_PI};                                          // 8/pi

s_oneEightsOfPi

double Muon::MuonSectorMapping::s_oneEightsOfPi {M_PI / 8.}

staticconstexprprivate

Definition at line 60 of file MuonSectorMapping.h.

{M_PI / 8.};                                                 //  pi/8

s_sectorOverlap

double Muon::MuonSectorMapping::s_sectorOverlap {0.1 * s_oneEightsOfPi}

staticconstexprprivate

Definition at line 63 of file MuonSectorMapping.h.

{0.1 * s_oneEightsOfPi};  // size of the overlap between small and large sectors

s_sectorSize

std::array<double, 2> Muon::MuonSectorMapping::s_sectorSize {0.4 * s_oneEightsOfPi, 0.6 * s_oneEightsOfPi}

staticconstexprprivate

Definition at line 62 of file MuonSectorMapping.h.

{0.4 * s_oneEightsOfPi, 0.6 * s_oneEightsOfPi};  // side of a sector in radiants

---

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

• MuonSectorMapping.h