MuonPadDesign Struct Reference

Parameters defining the design of the readout sTGC pads. More...

#include <MuonPadDesign.h>

Inheritance diagram for MuonPadDesign:

Collaboration diagram for MuonPadDesign:

Public Types
enum	padCorners { botLeft =0 , botRight , topLeft , topRight }
using	CornerArray = std::array<Amg::Vector2D, 4>
	calculate local channel corners for a given channel number

Public Member Functions
	MuonPadDesign ()
std::pair< int, int >	etaPhiId (const int channel) const
int	channelId (const std::pair< int, int > &padId) const
double	distanceToChannel (const Amg::Vector2D &pos, bool measPhi, int channel=0) const
	distance to channel - residual
Amg::Vector2D	distanceToPad (const Amg::Vector2D &pos, int channel) const
bool	withinSensitiveArea (const Amg::Vector2D &pos) const
	whether pos is within the sensitive area of the module
double	minSensitiveY () const
	lowest y (local) of the sensitive volume
double	maxSensitiveY () const
	highest y (local) of the sensitive volume
double	maxAbsSensitiveX (const double &y) const
	largest (abs, local) x of the sensitive volume
std::pair< int, int >	channelNumber (const Amg::Vector2D &pos) const
	calculate local channel number, range 1=nstrips like identifiers.
bool	channelPosition (const std::pair< int, int > &pad, Amg::Vector2D &pos) const
	calculate local channel position for a given channel number
bool	channelPosition (const int channel, Amg::Vector2D &pos) const
bool	channelCorners (const std::pair< int, int > &pad, CornerArray &corners) const
bool	channelCorners (const int channel, CornerArray &corners) const
double	channelWidth (const Amg::Vector2D &pos, bool measPhi, bool preciseMeas=false) const
	calculate local channel width
double	gasGapThickness () const
	thickness of gas gap
void	setR (double R)
	access to cache
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Public Attributes
int	padEtaMin {0}
int	padEtaMax {0}
double	inputRowPitch {0.}
double	inputPhiPitch {0.}
double	signY {0.}
double	firstRowPos {0.}
double	firstPhiPos {0.}
double	Length {0.}
double	sWidth {0.}
double	lWidth {0.}
double	Size {0.}
double	thickness {0.}
double	radialDistance {0.}
	DT-2015-11-29 distance from the beamline to the center of the module.
double	sPadWidth {0.}
double	lPadWidth {0.}
double	xFrame {0.}
double	ysFrame {0.}
double	ylFrame {0.}
double	yCutout {0.}
int	nPadH {0}
int	nPadColumns {0}
double	PadPhiShift {0.}
int	etasign {0}
int	isLargeSector {0}
double	sectorOpeningAngle {0.}
bool	isConvertedFromPhaseII {false}

Static Public Attributes
static constexpr double	largeSectorOpeningAngle {28.0}
static constexpr double	smallSectorOpeningAngle {17.0}

Private Member Functions
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

Detailed Description

Parameters defining the design of the readout sTGC pads.

The parameters below are the ones from the parameter book. The naming convention used here refers to the one explained on p.90 ("naming of .xml tags and .h variables") of https://twiki.cern.ch/twiki/bin/view/Atlas/NSWParameterBook#Parameter_book

Note that the pads do not exist as objects in memory. Instead, a MuonPadDesign is defined for each layer in a module. From the readout parameters one can map position <-> channel:

• for each sim hit position identify the pad (channel)
• for each channel determine the center position

Definition at line 37 of file MuonPadDesign.h.

Member Typedef Documentation

CornerArray

using MuonGM::MuonPadDesign::CornerArray = std::array<Amg::Vector2D, 4>

calculate local channel corners for a given channel number

Definition at line 98 of file MuonPadDesign.h.

Member Enumeration Documentation

padCorners

enum MuonGM::MuonPadDesign::padCorners

Enumerator
botLeft
botRight
topLeft
topRight

Definition at line 99 of file MuonPadDesign.h.

{ botLeft=0, botRight, topLeft, topRight };

Constructor & Destructor Documentation

MuonPadDesign()

MuonPadDesign::MuonPadDesign

(

)

Definition at line 12 of file MuonPadDesign.cxx.

: AthMessaging{"MuonPadDesign"}{}

Member Function Documentation

channelCorners() [1/2]

bool MuonPadDesign::channelCorners	(	const int	channel,
		CornerArray &	corners ) const

Definition at line 154 of file MuonPadDesign.cxx.

                                                                                {
    return channelCorners(etaPhiId(channel), corners);
}

channelCorners() [2/2]

bool MuonPadDesign::channelCorners	(	const std::pair< int, int > &	pad,
		CornerArray &	corners ) const

Definition at line 157 of file MuonPadDesign.cxx.

                                                                                           {
    // DG-2015-11-30: todo check whether the offset subtraction is still needed
    int iEta = pad.first;   // -1 + padEtaMin;
    int iPhi = pad.second;  //  -1 + padPhiMin;
    // bool invalid_indices = iEta<1 || iPhi<1; // DG-2015-11-30 do we still need to check this?
    // if(invalid_indices) return false;
    // double yBot = -0.5*Length + firstRowPos + ysFrame + iEta*inputRowPitch;
    // double yTop = -0.5*Length + firstRowPos + ysFrame + (iEta+1)*inputRowPitch;

    double yBot = 0., yTop = 0.;
    if (iEta == 1) {
        yBot = yCutout ? -(Size - yCutout) : -0.5 * Size;
        yTop = yBot + firstRowPos;
    } else if (iEta > 1) {
        yBot = yCutout ? -(Size - yCutout) + firstRowPos + (iEta - 2) * inputRowPitch 
                       : -0.5 * Size + firstRowPos + (iEta - 2) * inputRowPitch;
        yTop = yBot + inputRowPitch;
        if (iEta == nPadH) yTop = maxSensitiveY();
    } else {  // Unkwown ieta
        return false;
    }
 
    // restrict y to the module sensitive area
    double minY = minSensitiveY();
    double maxY = maxSensitiveY();
    if (yBot < minY) yBot = minY;
    if (yTop > maxY) yTop = maxY;
 
    // here L/R are defined as if you were looking from the IP to the
    // detector (same a clockwise/counterclockwise phi but shorter)
    double phiRight = firstPhiPos + (iPhi - 2) * inputPhiPitch;
    double phiLeft = firstPhiPos + (iPhi - 1) * inputPhiPitch;
 
    const double tanRight = std::tan(phiRight *CLHEP::degree);
    const double tanLeft = std::tan(phiLeft *CLHEP::degree);
    double xBotRight = -(yBot + radialDistance) * tanRight;
    double xBotLeft = -(yBot + radialDistance) * tanLeft;
    double xTopRight = -(yTop + radialDistance) * tanRight;
    double xTopLeft = -(yTop + radialDistance) * tanLeft;
  
    const double cosRight = (radialDistance + yBot) / std::hypot(xBotRight, (radialDistance + yBot));
    const double cosLeft = (radialDistance + yBot) / std::hypot(xBotLeft, (radialDistance + yBot));
    
    xBotRight += 1.*PadPhiShift*cosRight;
    xBotLeft += 1.*PadPhiShift*cosLeft;
    xTopRight += 1.*PadPhiShift*cosRight;
    xTopLeft += 1.*PadPhiShift*cosLeft;
 
    // For the R3 geometry converted from Phase II, we are shifting the gasgap center
    // to the center of the gap for L3, originally defined at the cutout base.
    // Hence, we are defining an offset, yCutoutOffset to be used in the pad corner calculations.
    double yCutoutOffset{0.};
    if(isConvertedFromPhaseII) {
        yCutoutOffset = 24.74;
    }
    // Adjust outer columns
    // No staggering from fuziness in the outer edges
    if (iPhi == 1) {
        double yLength = yCutout ? Size - yCutout + yCutoutOffset: Size;
        xBotRight = 0.5 * (sPadWidth + (lPadWidth - sPadWidth) * (yBot - minY) / yLength);
        xTopRight = 0.5 * (sPadWidth + (lPadWidth - sPadWidth) * (yTop - minY) / yLength);
    }
    if (iPhi == nPadColumns) {
        double yLength = yCutout ? Size - yCutout + yCutoutOffset: Size;
        xBotLeft = -0.5 * (sPadWidth + (lPadWidth - sPadWidth) * (yBot - minY) / yLength);
        xTopLeft = -0.5 * (sPadWidth + (lPadWidth - sPadWidth) * (yTop - minY) / yLength);
    }
 
    // Adjust for cutout region
    if (yCutout && (yTop - yCutoutOffset) > 0) {
        float cutoutXpos = 0.5 * lPadWidth;
        if (iPhi == 1) {
            xTopRight = cutoutXpos;
            if (yBot - yCutoutOffset > 0) xBotRight = cutoutXpos;
        } else if (iPhi == nPadColumns) {
            xTopLeft = -1.0 * cutoutXpos;
            if (yBot - yCutoutOffset > 0) xBotLeft = -1.0 * cutoutXpos;
        }
    }
    if (yBot > yTop) {
        ATH_MSG_VERBOSE("Swap top and bottom side "<<pad.first<<"/"<<pad.second);
        std::swap(yBot, yTop);
    }
    if (xBotLeft > xBotRight) {
        ATH_MSG_VERBOSE("Swap bottom left and right points "<<pad.first<<"/"<<pad.second);
        std::swap(xBotLeft, xBotRight);
    }
    if (xTopLeft > xTopRight) {
        ATH_MSG_VERBOSE("Swap top left and right points "<<pad.first<<"/"<<pad.second);
        std::swap(xTopLeft, xTopRight);
    }
    corners[botLeft] = Amg::Vector2D(xBotLeft, yBot);
    corners[botRight] = Amg::Vector2D(xBotRight, yBot);
    corners[topLeft] = Amg::Vector2D(xTopLeft, yTop);
    corners[topRight] = Amg::Vector2D(xTopRight, yTop);
    return true;
}

channelId()

int MuonGM::MuonPadDesign::channelId ( const std::pair< int, int > & padId ) const

inline

Definition at line 115 of file MuonPadDesign.h.

                                                                            {
        return 1 + (padId.first - 1)  + (padId.second - 1 ) * 18;
    }

channelNumber()

std::pair< int, int > MuonPadDesign::channelNumber

(

const Amg::Vector2D &

pos

)

const

calculate local channel number, range 1=nstrips like identifiers.

Returns -1 if out of range

Definition at line 39 of file MuonPadDesign.cxx.

                                                                           {
    /* Changes in this package are due to new geometry implementations
     * Correct active area position and inclusion of proper QL3 shape.
     * coordinates (0,0) now point to the center of the active region, not gas volume
     * for QL3, where ycutout !=0, (0,0) is at start of ycutout */
 
    // perform check of the sensitive area
    std::pair<int, int> result(-1, -1);
 
    // padEta
    double y1 = yCutout ? Size - yCutout + pos.y() : 0.5 * Size + pos.y();  // distance from small edge to hit
    double padEtadouble;
    int padEta = 0;
    // padPhi
    // To obtain the pad number of a given position, its easier to apply the
    // pad staggering to the position instead of the pad: apply -PadPhiShift.
    // Pad corners and positions however fully account for their staggering
    double locPhi = std::atan(-1.0 * pos.x() / (radialDistance + pos.y())) / CLHEP::degree;
    double maxlocPhi = std::atan(maxAbsSensitiveX(pos.y()) / (radialDistance + pos.y())) / CLHEP::degree;
    double fuzziedX = pos.x() - 1. * PadPhiShift * std::cos(locPhi * CLHEP::degree);
    double fuzziedlocPhi = std::atan(-1.0 * fuzziedX / (radialDistance + pos.y())) / CLHEP::degree;
 
    bool below_half_length = (y1 < 0);
    bool outside_phi_range = (std::abs(locPhi) > maxlocPhi) || (std::abs(fuzziedlocPhi) > maxlocPhi);
 
    if (withinSensitiveArea(pos) && !below_half_length) {
      if (y1 > firstRowPos) {
        //+1 for firstRow, +1 because a remainder means another row (3.1=4)
        padEtadouble = ((y1 - firstRowPos) / inputRowPitch) + 1 + 1;
        padEta = padEtadouble;
      } else if (y1 >= 0) {
        padEta = 1;
      }
      double padPhidouble;
      // These are separated as the hits on the pads closest to the side edges are not fuzzied
      // We must do a correction in order to stay consistent with indexing
      if (outside_phi_range)
        padPhidouble = (locPhi - firstPhiPos) / inputPhiPitch;
      else  // Look for the index of the fuzzied hit
        padPhidouble = (fuzziedlocPhi - firstPhiPos) / inputPhiPitch;
      int padPhi = padPhidouble + 2;  //(+1 because remainder means next column e.g. 1.1=2, +1 so rightmostcolumn=1)
 
      // adjust indices if necessary
      if (padEta == nPadH + 1) { padEta -= 1; }                 // the top row can be bigger, therefore it is really in the nPadH row.
      if (padPhi == 0) { padPhi = 1; }                          // adjust rightmost
      if (padPhi == nPadColumns + 1) { padPhi = nPadColumns; }  // adjust lefmost
 
      // final check on range
      bool ieta_out_of_range = (padEta > nPadH + 1);
      bool iphi_out_of_range = (padPhi < 0 || padPhi > nPadColumns + 1);
      bool index_out_of_range = ieta_out_of_range or iphi_out_of_range;
      if (index_out_of_range) {
          std::stringstream sstr{};
          if (ieta_out_of_range){
            sstr<<__FILE__<<":"<<__LINE__<<" "<<__func__<<"() eta out of range "
                <<Amg::toString(pos, 2)<<" (ieta, iphi) = ("<<padEta<<","<<padPhi<<").";
          } else {
            sstr<<__FILE__<<":"<<__LINE__<<" "<<__func__<<"() phi out of range "
                <<Amg::toString(pos, 2)<<" (ieta, iphi) = ("<<padEta<<","<<padPhi<<").";
          }
          throw std::runtime_error(sstr.str());
      
      } else {
          result = std::make_pair(padEta, padPhi);
      }
    }
    return result;
}

channelPosition() [1/2]

bool MuonPadDesign::channelPosition	(	const int	channel,
		Amg::Vector2D &	pos ) const

Definition at line 109 of file MuonPadDesign.cxx.

                                                                             {
    return channelPosition(etaPhiId(channel), pos);
}

channelPosition() [2/2]

bool MuonPadDesign::channelPosition	(	const std::pair< int, int > &	pad,
		Amg::Vector2D &	pos ) const

calculate local channel position for a given channel number

Definition at line 112 of file MuonPadDesign.cxx.

                                                                                        {
    CornerArray corners{make_array<Amg::Vector2D, 4>(Amg::Vector2D::Zero())};
    channelCorners(pad, corners);
    pos = 0.25 * (corners[botLeft] + corners[botRight] + corners[topLeft] + corners[topRight]); 
    return true;
}

channelWidth()

double MuonGM::MuonPadDesign::channelWidth ( const Amg::Vector2D & pos, bool measPhi, bool preciseMeas = false ) const

inline

calculate local channel width

Definition at line 139 of file MuonPadDesign.h.

                                                                                                          {
        // get Eta and Phi indices, and corner positions of given pad
        const std::pair<int, int>& pad = channelNumber(pos);
        std::array<Amg::Vector2D,4> corners{make_array<Amg::Vector2D, 4>(Amg::Vector2D::Zero())};
        channelCorners(pad, corners);
 
        // For eta pad measurement, return height of given pad
        if (!measPhi) return corners.at(2)[1] - corners.at(0)[1];
 
        // Return the width at the top of the pads
        /* This is used by default and allows for track/segment association to pads to work correctly
           In these cases, the given position of the pad is always its centre so we can not know the
           precise position where we want to compute the width so its best to give a larger value
        */
        if (!preciseMeas) return corners.at(3)[0] - corners.at(2)[0];
 
        // Return precise Phi width for a given precise position on the pad
        /* This is only used when the precise position of a hit, track or segment is known on the pad
           Only to be used in specific cases, like in the digitization when we need to know the exact
           width along a certain point in the pad, e.g. for charge sharing. 
        */
        
        double WidthTop = corners.at(3)[0] - corners.at(2)[0];
        double WidthBot = corners.at(1)[0] - corners.at(0)[0];
        return WidthBot + (WidthTop - WidthBot) * (pos.y() - corners.at(0)[1]) / (corners.at(2)[1]-corners.at(0)[1]);
    }

distanceToChannel()

double MuonGM::MuonPadDesign::distanceToChannel ( const Amg::Vector2D & pos, bool measPhi, int channel = 0 ) const

inline

distance to channel - residual

Definition at line 119 of file MuonPadDesign.h.

                                                                                                          {
        // if channel number not provided, get the nearest channel ( mostly for validation purposes )
 
        std::pair<int, int> pad{};
        if (channel < 1) {  // retrieve nearest pad indices
            pad = channelNumber(pos);
        } else {  // hardcode - or add a member saving idHelper max
            pad = etaPhiId(channel);
        }
 
        Amg::Vector2D chPos{Amg::Vector2D::Zero()};
        if (!channelPosition(pad, chPos)) return -10000.;
 
        if (!measPhi) return (pos.y() - chPos.y());
 
        // the "phi" distance to be compared with channel width (taking into account the stereo angle)
 
        return (pos.x() - chPos.x());
    }

distanceToPad()

Amg::Vector2D MuonPadDesign::distanceToPad	(	const Amg::Vector2D &	pos,
		int	channel ) const

In terms of y the hit could be in the pad

Hit is inside the pad

Definition at line 118 of file MuonPadDesign.cxx.

                                                                                  {
    CornerArray corners{make_array<Amg::Vector2D, 4>(Amg::Vector2D::Zero())};
    channelCorners(channel, corners);
 
    Amg::Vector2D leftEdge = corners[topLeft] - corners[botLeft];
    const double lenLeft = std::hypot(leftEdge.x(), leftEdge.y());
    leftEdge /= lenLeft;
    const double leftIsect = Amg::intersect<2>(pos, Amg::Vector2D::UnitX(),
                                                 corners[botLeft], leftEdge).value_or(1.e9);
 
    const Amg::Vector2D leftPad = corners[botLeft] + leftIsect * leftEdge;
    const Amg::Vector2D rightPad = corners[botRight] + leftIsect * (corners[topRight] - corners[botRight]).unit();
    const double deltaX = pos.x() - leftPad.x();
    const double lenX = rightPad.x() - leftPad.x();
       
    if (leftIsect >= 0.  && leftIsect <= lenLeft) {
       if (deltaX >= 0. && deltaX < lenX) {
            return Amg::Vector2D::Zero();
       } else if (deltaX < 0.) {
            return deltaX * Amg::Vector2D::UnitX();
       }
       return (deltaX - lenX) * Amg::Vector2D::UnitX();
    }
    if (deltaX > 0.  && deltaX < lenX) {
        return (leftIsect < 0 ? corners[botRight].y() - pos.y() 
                              : pos.y() - corners[topRight].y())* Amg::Vector2D::UnitY();
    }
    return (leftIsect < 0 ? corners[botRight].y() - pos.y() 
                              : pos.y() - corners[topRight].y())* Amg::Vector2D::UnitY() +
           (deltaX < 0. ? deltaX  : (deltaX - lenX) )* Amg::Vector2D::UnitX();
 
}

etaPhiId()

std::pair< int, int > MuonGM::MuonPadDesign::etaPhiId ( const int channel ) const

inline

Definition at line 112 of file MuonPadDesign.h.

                                                                            {        
        return std::make_pair( ((channel -1) % 18) + 1, ( (channel -1) / 18) + 1);
    }

gasGapThickness()

double MuonGM::MuonPadDesign::gasGapThickness ( ) const

inline

thickness of gas gap

Definition at line 166 of file MuonPadDesign.h.

{ return thickness; }

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

maxAbsSensitiveX()

double MuonPadDesign::maxAbsSensitiveX

(

const double &

y

)

const

largest (abs, local) x of the sensitive volume

Definition at line 26 of file MuonPadDesign.cxx.

                                                            {
    double half_openingAngle = sectorOpeningAngle / 2.0;
    if (isLargeSector && yCutout) {  // if QL3
        if (y > 0)                   // In cutout region
            return 0.5 * lPadWidth;
        else
            return y * std::tan(half_openingAngle * CLHEP::degree) + 0.5 * lPadWidth;
    } else
        return (y - Size * 0.5) * std::tan(half_openingAngle * CLHEP::degree) + 0.5 * lPadWidth;
 
    return -1;
}

maxSensitiveY()

double MuonPadDesign::maxSensitiveY

(

)

const

highest y (local) of the sensitive volume

Definition at line 24 of file MuonPadDesign.cxx.

{ return yCutout ? yCutout : 0.5 * Size; }

minSensitiveY()

double MuonPadDesign::minSensitiveY

(

)

const

lowest y (local) of the sensitive volume

Definition at line 22 of file MuonPadDesign.cxx.

{ return yCutout ? -(Size - yCutout) : -0.5 * Size; }

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 163 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 178 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

setR()

void MuonGM::MuonPadDesign::setR ( double R )

inline

access to cache

Definition at line 109 of file MuonPadDesign.h.

{ this->radialDistance = R; }

withinSensitiveArea()

bool MuonPadDesign::withinSensitiveArea

(

const Amg::Vector2D &

pos

)

const

whether pos is within the sensitive area of the module

Definition at line 13 of file MuonPadDesign.cxx.

                                                                    {
    double top_H1 = maxSensitiveY();
    double bot_H2 = minSensitiveY();
    double max_x = maxAbsSensitiveX(pos.y());
    bool y_in_range = (pos.y() <= top_H1 and pos.y() >= bot_H2);
    bool x_in_range = std::abs(pos.x()) <= max_x + 0.01;
    return y_in_range and x_in_range;
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

etasign

int MuonGM::MuonPadDesign::etasign {0}

Definition at line 65 of file MuonPadDesign.h.

{0};

firstPhiPos

double MuonGM::MuonPadDesign::firstPhiPos {0.}

Definition at line 47 of file MuonPadDesign.h.

{0.};

firstRowPos

double MuonGM::MuonPadDesign::firstRowPos {0.}

Definition at line 46 of file MuonPadDesign.h.

{0.};

inputPhiPitch

double MuonGM::MuonPadDesign::inputPhiPitch {0.}

Definition at line 44 of file MuonPadDesign.h.

{0.};

inputRowPitch

double MuonGM::MuonPadDesign::inputRowPitch {0.}

Definition at line 43 of file MuonPadDesign.h.

{0.};

isConvertedFromPhaseII

bool MuonGM::MuonPadDesign::isConvertedFromPhaseII {false}

Definition at line 68 of file MuonPadDesign.h.

{false};

isLargeSector

int MuonGM::MuonPadDesign::isLargeSector {0}

Definition at line 66 of file MuonPadDesign.h.

{0};

largeSectorOpeningAngle

double MuonGM::MuonPadDesign::largeSectorOpeningAngle {28.0}

staticconstexpr

Definition at line 69 of file MuonPadDesign.h.

{28.0};

Length

double MuonGM::MuonPadDesign::Length {0.}

Definition at line 49 of file MuonPadDesign.h.

{0.};

lPadWidth

double MuonGM::MuonPadDesign::lPadWidth {0.}

Definition at line 57 of file MuonPadDesign.h.

{0.};

lWidth

double MuonGM::MuonPadDesign::lWidth {0.}

Definition at line 51 of file MuonPadDesign.h.

{0.};

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

nPadColumns

int MuonGM::MuonPadDesign::nPadColumns {0}

Definition at line 63 of file MuonPadDesign.h.

{0};

nPadH

int MuonGM::MuonPadDesign::nPadH {0}

Definition at line 62 of file MuonPadDesign.h.

{0};

padEtaMax

int MuonGM::MuonPadDesign::padEtaMax {0}

Definition at line 41 of file MuonPadDesign.h.

{0};

padEtaMin

int MuonGM::MuonPadDesign::padEtaMin {0}

Definition at line 40 of file MuonPadDesign.h.

{0};

PadPhiShift

double MuonGM::MuonPadDesign::PadPhiShift {0.}

Definition at line 64 of file MuonPadDesign.h.

{0.};

radialDistance

double MuonGM::MuonPadDesign::radialDistance {0.}

DT-2015-11-29 distance from the beamline to the center of the module.

Definition at line 54 of file MuonPadDesign.h.

{0.};  

sectorOpeningAngle

double MuonGM::MuonPadDesign::sectorOpeningAngle {0.}

Definition at line 67 of file MuonPadDesign.h.

{0.};

signY

double MuonGM::MuonPadDesign::signY {0.}

Definition at line 45 of file MuonPadDesign.h.

{0.};

Size

double MuonGM::MuonPadDesign::Size {0.}

Definition at line 52 of file MuonPadDesign.h.

{0.};

smallSectorOpeningAngle

double MuonGM::MuonPadDesign::smallSectorOpeningAngle {17.0}

staticconstexpr

Definition at line 70 of file MuonPadDesign.h.

{17.0};

sPadWidth

double MuonGM::MuonPadDesign::sPadWidth {0.}

Definition at line 56 of file MuonPadDesign.h.

{0.};

sWidth

double MuonGM::MuonPadDesign::sWidth {0.}

Definition at line 50 of file MuonPadDesign.h.

{0.};

thickness

double MuonGM::MuonPadDesign::thickness {0.}

Definition at line 53 of file MuonPadDesign.h.

{0.};

xFrame

double MuonGM::MuonPadDesign::xFrame {0.}

Definition at line 58 of file MuonPadDesign.h.

{0.};

yCutout

double MuonGM::MuonPadDesign::yCutout {0.}

Definition at line 61 of file MuonPadDesign.h.

{0.};

ylFrame

double MuonGM::MuonPadDesign::ylFrame {0.}

Definition at line 60 of file MuonPadDesign.h.

{0.};

ysFrame

double MuonGM::MuonPadDesign::ysFrame {0.}

Definition at line 59 of file MuonPadDesign.h.

{0.};

---

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

• MuonPadDesign.h
• MuonPadDesign.cxx