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 More...
int	getSector (double phi) const
	returns the sector corresponding to the phi position More...
void	getSectors (double phi, std::vector< int > &sectors) const
	returns the main sector plus neighboring if the phi position is in an overlap region More...
double	sectorPhi (int sector) const
	returns the centeral phi position of a sector in radians More...
double	transformPhiToSector (double phi, int sector, bool toSector=true) const
	transforms a phi position from and to the sector coordinate system in radians More...
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 More...
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 More...
bool	closeToSectorBoundary (double phi) const
	checks whether the phi position is close to a sector boundary More...
double	transformRToNeighboringSector (double r, int sectorHit, int sectorTarget) const
	transform a radial position from one sector frame into another More...
double	sectorSize (int sector) const
	sector size (exclusive) in radians More...
double	sectorWidth (int sector) const
	sector width (with overlap) in radians More...

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()

static 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 = sector1 < sector2 ? sector1 : sector2;
        int s2 = sector1 > sector2 ? 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

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

staticconstexprprivate

Definition at line 61 of file MuonSectorMapping.h.

s_oneEightsOfPi

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

staticconstexprprivate

Definition at line 60 of file MuonSectorMapping.h.

s_sectorOverlap

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

staticconstexprprivate

Definition at line 63 of file MuonSectorMapping.h.

s_sectorSize

constexpr 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.

---

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

• MuonSectorMapping.h