TrigL2MuonSA::MdtRegionDefiner Class Reference

#include <MdtRegionDefiner.h>

Inheritance diagram for TrigL2MuonSA::MdtRegionDefiner:

Collaboration diagram for TrigL2MuonSA::MdtRegionDefiner:

Public Member Functions
virtual StatusCode	initialize () override
void	setRpcGeometry (bool use_rpc)
StatusCode	getMdtRegions (const TrigRoiDescriptor *p_roids, const TrigL2MuonSA::RpcFitResult &rpcFitResult, TrigL2MuonSA::MuonRoad &muonRoad, TrigL2MuonSA::MdtRegion &mdtRegion) const
StatusCode	getMdtRegions (const TrigRoiDescriptor *p_roids, const TrigL2MuonSA::TgcFitResult &tgcFitResult, TrigL2MuonSA::MuonRoad &muonRoad, TrigL2MuonSA::MdtRegion &mdtRegion) const
	AthAlgTool (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor with parameters:
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static void	find_station_sector (const std::string &name, int phi, bool &endcap, int &chamber, int &sector)

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	prepareTgcPoints (const TrigL2MuonSA::TgcHits &tgcHits)
void	find_barrel_road_dim (const float max_road, const float aw, const float bw, const float rMmin, const float rMax, float &zMin, float &zMax) const
void	find_endcap_road_dim (const float road, const float aw, const float bw, const float zMin, const float zMax, float &rMin, float &rMax) const
void	find_eta_min_max (float zMin, float rMin, float zMax, float rMax, float &etaMin, float &etaMax) const
void	find_phi_min_max (float phiMiddle, float &phiMin, float &phiMax) const
StatusCode	computePhi (const TrigRoiDescriptor *p_roids, const TrigL2MuonSA::TgcFitResult &tgcFitResult, const TrigL2MuonSA::MdtRegion &mdtRegion, TrigL2MuonSA::MuonRoad &muonRoad) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_muDetMgrKey {this, "DetectorManagerKey", "MuonDetectorManager", "Key of input MuonDetectorManager condition data"}
bool	m_use_rpc {true}
TrigL2MuonSA::TgcFit::PointArray	m_tgcStripMidPoints
TrigL2MuonSA::TgcFit::PointArray	m_tgcWireMidPoints
TrigL2MuonSA::TgcFit::PointArray	m_tgcStripInnPoints
TrigL2MuonSA::TgcFit::PointArray	m_tgcWireInnPoints
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 37 of file MdtRegionDefiner.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Function Documentation

AthAlgTool()

AthAlgTool::AthAlgTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Constructor with parameters:

Definition at line 31 of file AthAlgTool.cxx.

                                       : 
  AthCommonDataStore<AthCommonMsg<AlgTool>> ( type, name, parent )
{
}

computePhi()

StatusCode TrigL2MuonSA::MdtRegionDefiner::computePhi ( const TrigRoiDescriptor * p_roids, const TrigL2MuonSA::TgcFitResult & tgcFitResult, const TrigL2MuonSA::MdtRegion & mdtRegion, TrigL2MuonSA::MuonRoad & muonRoad ) const

private

Definition at line 500 of file MdtRegionDefiner.cxx.

{
  int endcap_inner = xAOD::L2MuonParameters::Chamber::EndcapInner;
  int endcap_middle = xAOD::L2MuonParameters::Chamber::EndcapMiddle;
  int endcap_outer = xAOD::L2MuonParameters::Chamber::EndcapOuter;
  int barrel_inner = xAOD::L2MuonParameters::Chamber::BarrelInner;
 
  for(int i_station=0; i_station<5; i_station++) {
    int chamber = 0;
    if (i_station==0) chamber = xAOD::L2MuonParameters::Chamber::EndcapInner;
    if (i_station==1) chamber = xAOD::L2MuonParameters::Chamber::EndcapMiddle;
    if (i_station==2) chamber = xAOD::L2MuonParameters::Chamber::EndcapOuter;
    if (i_station==3) chamber = xAOD::L2MuonParameters::Chamber::EndcapExtra;
    if (i_station==4) chamber = xAOD::L2MuonParameters::Chamber::BarrelInner;
    for( int i_sector=0; i_sector<2; i_sector++) {
 
      if ( tgcFitResult.isSuccess ) {
    if (chamber==endcap_middle || !tgcFitResult.isPhiDir) {
      muonRoad.phi[chamber][i_sector] = tgcFitResult.phi;
      continue;
    }
    
    muonRoad.phi[chamber][i_sector] = 0.;
    double dz = 0.;
    
    if (chamber==endcap_outer) {
      
      double MiddleZ = std::abs(mdtRegion.zMin[endcap_middle][i_sector] + mdtRegion.zMax[endcap_middle][i_sector])/2.;
      double MiddleR = MiddleZ*muonRoad.aw[endcap_middle][i_sector] + muonRoad.bw[endcap_middle][i_sector];
      
      double OuterZ  = std::abs(mdtRegion.zMin[endcap_outer][i_sector] + mdtRegion.zMax[endcap_outer][i_sector])/2.;
      double OuterR  = OuterZ*muonRoad.aw[endcap_outer][i_sector] + muonRoad.bw[endcap_outer][i_sector];
      double DrOuter = std::abs(OuterR-MiddleR);
      dz = std::sqrt((OuterZ-MiddleZ)*(OuterZ-MiddleZ) + DrOuter*DrOuter);
      dz = (OuterZ-MiddleZ);
      
    } if (chamber==endcap_inner || chamber==barrel_inner) {
 
      double MiddleZ = 0;
      double MiddleR = 0;
      
      if(tgcFitResult.tgcInn[2] != 0.) {
        muonRoad.phi[chamber][i_sector] = tgcFitResult.tgcInn[1];
        continue;
      }
      double InnerZ  = std::abs(mdtRegion.zMin[endcap_inner][i_sector] + mdtRegion.zMax[endcap_inner][i_sector])/2.;
      double InnerR  = InnerZ*muonRoad.aw[endcap_inner][i_sector] + muonRoad.bw[endcap_inner][i_sector];
      double DrInner = std::abs(InnerR-MiddleR);
      dz = -std::sqrt((InnerZ-MiddleZ)*(InnerZ-MiddleZ) + DrInner*DrInner);
      dz = -std::abs(InnerZ-MiddleZ);
    }
        
    muonRoad.phi[chamber][i_sector] = (dz)* tgcFitResult.dPhidZ + tgcFitResult.phi;
    while (muonRoad.phi[chamber][i_sector] > M_PI)  muonRoad.phi[chamber][i_sector] -= 2*M_PI;
    while (muonRoad.phi[chamber][i_sector] <-M_PI)  muonRoad.phi[chamber][i_sector] += 2*M_PI;
 
      } else {
        // TGC data is not read -> use RoI
        muonRoad.phi[chamber][i_sector] = p_roids->phi();
      }
    }
  }
  return StatusCode::SUCCESS;
}  

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

find_barrel_road_dim()

void TrigL2MuonSA::MdtRegionDefiner::find_barrel_road_dim ( const float max_road, const float aw, const float bw, const float rMmin, const float rMax, float & zMin, float & zMax ) const

private

Definition at line 412 of file MdtRegionDefiner.cxx.

{
  float ia,dz,z1,z2;
  
  zMin =  9999.;
  zMax = -9999.;
  
  if(aw) {
    ia  = 1/aw;
  } else {
    ia  = 0;
  }
  
  dz = max_road*std::sqrt(1.+ia*ia);
  z1  = (ia)? (rMin-bw)*ia : bw;
  z2  = (ia)? (rMax-bw)*ia : bw;
 
  zMin = std::min({z1-dz, z1+dz, z2-dz, z2+dz});
  zMax = std::max({z1-dz, z1+dz, z2-dz, z2+dz});
}

find_endcap_road_dim()

void TrigL2MuonSA::MdtRegionDefiner::find_endcap_road_dim ( const float road, const float aw, const float bw, const float zMin, const float zMax, float & rMin, float & rMax ) const

private

Definition at line 437 of file MdtRegionDefiner.cxx.

{
    float r1{},r2{};
 
    rMin = 999999.;
    rMax = 0.;
    if(zMin>=99999. && zMax<=-99999.){
        rMin = 0.;
        rMax = 0.;
        return;
    }
 
    r1 = zMin*aw + bw;
    r2 = zMax*aw + bw;
    rMin = std::min({r1-road, r1+road, r2-road, r2+road});
    rMax = std::max({r1-road, r1+road, r2-road, r2+road});
 
    if(rMin<0.) rMin = 0.;
    if(rMax<0.) rMax = 0.;
}

find_eta_min_max()

void TrigL2MuonSA::MdtRegionDefiner::find_eta_min_max ( float zMin, float rMin, float zMax, float rMax, float & etaMin, float & etaMax ) const

private

Definition at line 377 of file MdtRegionDefiner.cxx.

                                                                 {   
   etaMin = 0.;
   etaMax = 0.;
 
   if(rMin > 0 && rMax > 0){
      std::array<float,4> eta{};
      float theta;
 
      theta  = (std::abs(zMin)>0.1)? std::atan(rMin/std::abs(zMin)): M_PI/2.;
      eta[0] = (zMin>0.)?  -std::log(std::tan(theta/2.)) : std::log(std::tan(theta/2.));
 
      theta  = (std::abs(zMax)>0.1)? std::atan(rMin/std::abs(zMax)): M_PI/2.;
      eta[1] = (zMax>0.)?  -std::log(std::tan(theta/2.)) : std::log(std::tan(theta/2.));
 
      theta  = (std::abs(zMax)>0.1)? std::atan(rMax/std::abs(zMax)): M_PI/2.;
      eta[2] = (zMax>0.)?  -std::log(std::tan(theta/2.)) : std::log(std::tan(theta/2.));
 
      theta  = (std::abs(zMin)>0.1)? std::atan(rMax/std::abs(zMin)): M_PI/2.;
      eta[3] = (zMin>0.)?  -std::log(std::tan(theta/2.)) : std::log(std::tan(theta/2.));
 
      etaMin = *std::min_element(std::begin(eta), std::end(eta));
      etaMax = *std::max_element(std::begin(eta), std::end(eta));
 
      if (etaMin > etaMax) {
        float tmp = etaMax;
        etaMax = etaMin;
        etaMin = tmp;
      }
   }
}

find_phi_min_max()

void TrigL2MuonSA::MdtRegionDefiner::find_phi_min_max ( float phiMiddle, float & phiMin, float & phiMax ) const

private

Definition at line 366 of file MdtRegionDefiner.cxx.

{   
   phiMin = phiMiddle - 0.1;
   phiMax = phiMiddle + 0.1;
   if ( phiMin < -1.*M_PI ) phiMin += 2.*M_PI;
   if ( phiMax > 1.*M_PI ) phiMax -= 2.*M_PI;
}

find_station_sector()

void TrigL2MuonSA::MdtRegionDefiner::find_station_sector ( const std::string & name, int phi, bool & endcap, int & chamber, int & sector )

static

Definition at line 329 of file MdtRegionDefiner.cxx.

{   
  endcap = (name[0]=='E' || name[0]=='F' || (name[0]=='B' && name[1]=='E')) ? true : false;
 
  int largeSmall=0;
  if(name[2]=='S' || name[2]=='F' || name[2]=='G') largeSmall = 1;//Small
  if (name[1]=='E' && name[2]=='E') largeSmall=1;//BEE
  sector = (phi-1)*2 + largeSmall;
  if (endcap){
    if(name[1]=='I')            //EI
      chamber = 3;
    if(name[1]=='M')
      chamber = 4;
    if(name[1]=='O')
      chamber = 5;
    if(name[1]=='E')
      chamber = 6;
    if(name[1]=='E' && name[2]=='E')//BEE
      chamber = 8;
  }else {
    if(name[1]=='I')
      chamber = 0;
    if(name[1]=='M')
      chamber = 1;
    if(name[1]=='O')
      chamber = 2;
    if(name[1]=='M' && name[2]=='E')//BME
      chamber = 9;
    if(name[1]=='M' && name[2]=='G')//BMG
      chamber = 10;
  }
}

getMdtRegions() [1/2]

StatusCode TrigL2MuonSA::MdtRegionDefiner::getMdtRegions	(	const TrigRoiDescriptor *	p_roids,
		const TrigL2MuonSA::RpcFitResult &	rpcFitResult,
		TrigL2MuonSA::MuonRoad &	muonRoad,
		TrigL2MuonSA::MdtRegion &	mdtRegion ) const

Definition at line 29 of file MdtRegionDefiner.cxx.

{
    mdtRegion.Clear();
 
    SG::ReadCondHandle<MuonGM::MuonDetectorManager> muDetMgrHandle{m_muDetMgrKey};
    const MuonGM::MuonDetectorManager* muDetMgr = muDetMgrHandle.cptr();
 
    for(int i_station=0; i_station<6; i_station++) {
        int chamber = 0;
        if (i_station==0) chamber = xAOD::L2MuonParameters::Chamber::BarrelInner;
        if (i_station==1) chamber = xAOD::L2MuonParameters::Chamber::BarrelMiddle;
        if (i_station==2) chamber = xAOD::L2MuonParameters::Chamber::BarrelOuter;
        if (i_station==3) chamber = xAOD::L2MuonParameters::Chamber::BME;
        if (i_station==4) chamber = xAOD::L2MuonParameters::Chamber::EndcapInner;
        if (i_station==5) chamber = xAOD::L2MuonParameters::Chamber::Backup; // BMG
 
        for(int i_sector=0; i_sector<N_SECTOR; i_sector++) { // 0: normal, 1: overlap
            const int sector = (i_sector == 0) ? muonRoad.MDT_sector_trigger : muonRoad.MDT_sector_overlap;
            ATH_MSG_DEBUG("--- chamber/sector=" << chamber << "/" << sector);
            if( sector==99 ) continue;
            
            float zMin {0}, zMax {0}, rMin {0}, rMax {0};
            float tmp_zMin {0}, tmp_zMax {0}, tmp_rMin {0}, tmp_rMax {0};
            float etaMin {0}, etaMax {0}, phiMin {0}, phiMax {0};
            int ty1 {-1}, ty2 {-1};
            int sign = 1;
            
            for(unsigned int sta_iter=0; sta_iter< muonRoad.stationList.size(); sta_iter++){
 
                Identifier id = muonRoad.stationList[sta_iter];
                int stationPhi = m_idHelperSvc->mdtIdHelper().stationPhi(id);
                std::string name = m_idHelperSvc->mdtIdHelper().stationNameString(m_idHelperSvc->mdtIdHelper().stationName(id));
                int chamber_this = 99;
                int sector_this = 99;
                bool isEndcap;
                find_station_sector(name, stationPhi, isEndcap, chamber_this, sector_this);
 
                if(chamber_this == chamber && sector_this == sector ){
 
                    if(ty1 == -1)      ty1 = m_idHelperSvc->mdtIdHelper().stationNameIndex(name)+1;
                    else if(ty2 == -1) ty2 = m_idHelperSvc->mdtIdHelper().stationNameIndex(name)+1;
                        
                    const MuonGM::MuonStation* muonStation = muDetMgr->getMdtReadoutElement(id)->parentMuonStation();
                    Amg::Transform3D trans =muonStation->getNominalAmdbLRSToGlobal();
                    Amg::Vector3D OrigOfMdtInAmdbFrame = muonStation->getBlineFixedPointInAmdbLRS() ;
 
                    if ( chamber_this == xAOD::L2MuonParameters::Chamber::EndcapInner ){
                        tmp_zMin = (trans*OrigOfMdtInAmdbFrame).z();
                        if(tmp_zMin < 0) sign = -1;
                        else if(tmp_zMin > 0) sign = 1;
                        tmp_zMax = tmp_zMin + sign*muonStation->Zsize();
                        if(zMin==0 || tmp_zMin < zMin) zMin = tmp_zMin;
                        if(zMax==0 || tmp_zMax > zMax) zMax = tmp_zMax;
                    }else{
                        tmp_rMin = (trans*OrigOfMdtInAmdbFrame).perp();
                        tmp_rMax = tmp_rMin + muonStation->Rsize();
                        if(rMin==0 || tmp_rMin < rMin) rMin = tmp_rMin;
                        if(rMax==0 || tmp_rMax > rMax) rMax = tmp_rMax;
                    }
                }
            }
 
            if ( chamber == xAOD::L2MuonParameters::Chamber::EndcapInner ){
                find_endcap_road_dim(muonRoad.rWidth[chamber][0],
                    muonRoad.aw[chamber][i_sector],
                    muonRoad.bw[chamber][i_sector],
                    zMin,zMax,
                    rMin,rMax);
            } else { 
                find_barrel_road_dim(muonRoad.MaxWidth(chamber),
                    muonRoad.aw[chamber][i_sector],
                    muonRoad.bw[chamber][i_sector],
                    rMin, rMax,
                    zMin, zMax);
            }
 
            ATH_MSG_DEBUG("...zMin/zMax/ty1/ty2=" << zMin << "/" << zMax << "/" << ty1 << "/" << ty2);
            ATH_MSG_DEBUG("...rMin/rMax=" << rMin << "/" << rMax);
            
            find_eta_min_max(zMin, rMin, zMax, rMax, etaMin, etaMax);
            find_phi_min_max(muonRoad.phiRoI, phiMin, phiMax);
 
            ATH_MSG_DEBUG("...etaMin/etaMax/phiMin/phiMax=" << etaMin << "/" << etaMax << "/" << phiMin << "/" << phiMax);
 
            mdtRegion.zMin[chamber][i_sector] = zMin;
            mdtRegion.zMax[chamber][i_sector] = zMax;
            mdtRegion.rMin[chamber][i_sector] = rMin;
            mdtRegion.rMax[chamber][i_sector] = rMax;
            mdtRegion.etaMin[chamber][i_sector] = etaMin;
            mdtRegion.etaMax[chamber][i_sector] = etaMax;
            mdtRegion.phiMin[chamber][i_sector] = phiMin;
            mdtRegion.phiMax[chamber][i_sector] = phiMax;
            for(int i_type=0; i_type<2; i_type++) {
                int type = (i_type==0) ? ty1 : ty2;
                if( type == -1 ) continue;
                mdtRegion.chamberType[chamber][i_sector][i_type] = type;
            }
        }
    }
    // use phi from the fit. If InsideOut, use phi from the RoI
    double phi = (m_use_rpc && rpcFitResult.isSuccess) ? rpcFitResult.phi : p_roids->phi(); 
    for (int i=0; i<6; i++){
        for (int j=0; j<N_SECTOR; j++){
            if (i==4) muonRoad.phi[9][j] = phi;
            else if (i==5) muonRoad.phi[10][j] = phi;
            else muonRoad.phi[i][j] = phi;
        }
    }
 
    return StatusCode::SUCCESS;
}

getMdtRegions() [2/2]

StatusCode TrigL2MuonSA::MdtRegionDefiner::getMdtRegions	(	const TrigRoiDescriptor *	p_roids,
		const TrigL2MuonSA::TgcFitResult &	tgcFitResult,
		TrigL2MuonSA::MuonRoad &	muonRoad,
		TrigL2MuonSA::MdtRegion &	mdtRegion ) const

Definition at line 147 of file MdtRegionDefiner.cxx.

{
  mdtRegion.Clear();
  
  int sectors[2];
  
  sectors[0] = muonRoad.MDT_sector_trigger;
  sectors[1] = muonRoad.MDT_sector_overlap;
  
  int endcap_middle = xAOD::L2MuonParameters::Chamber::EndcapMiddle;
  int barrel_inner = xAOD::L2MuonParameters::Chamber::BarrelInner;
  int bee = xAOD::L2MuonParameters::Chamber::BEE;
 
  SG::ReadCondHandle<MuonGM::MuonDetectorManager> muDetMgrHandle{m_muDetMgrKey};
  const MuonGM::MuonDetectorManager* muDetMgr = muDetMgrHandle.cptr();
 
  for(int i_station=0; i_station<7; i_station++) {
    int chamber = 0;
    if (i_station==0) chamber = xAOD::L2MuonParameters::Chamber::EndcapInner;
    if (i_station==1) chamber = xAOD::L2MuonParameters::Chamber::EndcapMiddle;
    if (i_station==2) chamber = xAOD::L2MuonParameters::Chamber::EndcapOuter;
    if (i_station==3) chamber = xAOD::L2MuonParameters::Chamber::EndcapExtra;
    if (i_station==4) chamber = xAOD::L2MuonParameters::Chamber::BarrelInner;
    if (i_station==5) chamber = xAOD::L2MuonParameters::Chamber::BEE;
    if (i_station==6) chamber = xAOD::L2MuonParameters::Chamber::Backup;
    for(int i_sector=0; i_sector<2; i_sector++) { // 0: normal, 1: overlap
      int sector = sectors[i_sector];
      ATH_MSG_DEBUG("--- chamber/sector=" << chamber << "/" << sector);
      if( sector==99 ) continue;
      float zMin   = 0;
      float zMax   = 0;
      float rMin   = 0;
      float rMax   = 0;
      float etaMin = 0;
      float etaMax = 0;
      float phiMin = 0;
      float phiMax = 0;
      int types[2];
      int& ty1 = types[0];
      int& ty2 = types[1];
      float sta_zMin = 0;
      float sta_zMax = 0;
    
      float tmp_zMin = 0;
      float tmp_zMax = 0;
      float tmp_rMin = 0;
      float tmp_rMax = 0;
      int sign = 1;
      ty1 = -1;
      ty2 = -1;
      
      for(unsigned int sta_iter=0; sta_iter<muonRoad.stationList.size(); sta_iter++){
    Identifier id = muonRoad.stationList[sta_iter];
    int stationPhi = m_idHelperSvc->mdtIdHelper().stationPhi(id);
    std::string name = m_idHelperSvc->mdtIdHelper().stationNameString(m_idHelperSvc->mdtIdHelper().stationName(id));
    int chamber_this = 99;
    int sector_this = 99;
    bool isEndcap;
    find_station_sector(name, stationPhi, isEndcap, chamber_this, sector_this);
        ATH_MSG_DEBUG("name/stationPhi/isEndcap/chamber_this/sector_this=" <<
              name << "/" << stationPhi << "/" << isEndcap << "/" << chamber_this << "/" << sector_this);
    
    if(chamber_this == chamber && sector_this == sector){
      if(ty1 == -1)
        ty1 = m_idHelperSvc->mdtIdHelper().stationNameIndex(name)+1;
      else if(ty2 == -1)
        ty2 = m_idHelperSvc->mdtIdHelper().stationNameIndex(name)+1;
          
          const MuonGM::MdtReadoutElement* mdtReadout = muDetMgr->getMdtReadoutElement(id);
          const MuonGM::MuonStation* muonStation = mdtReadout->parentMuonStation();
    
      float scale = 10.;
      
      Amg::Transform3D trans = muonStation->getNominalAmdbLRSToGlobal();
      
      Amg::Vector3D OrigOfMdtInAmdbFrame =  muonStation->getBlineFixedPointInAmdbLRS();
      
      tmp_zMin = (trans*OrigOfMdtInAmdbFrame).z();
      if(tmp_zMin < 0) sign = -1;
      else if(tmp_zMin > 0) sign = 1;
      tmp_zMax = tmp_zMin + sign*muonStation->Zsize();
      
      if(sta_zMin==0 || tmp_zMin<sta_zMin) sta_zMin = tmp_zMin;
      if(sta_zMin==0 || tmp_zMax<sta_zMin) sta_zMin = tmp_zMax;
      if(sta_zMax==0 || tmp_zMax>sta_zMax) sta_zMax = tmp_zMax;
      if(sta_zMax==0 || tmp_zMin>sta_zMax) sta_zMax = tmp_zMin;
      
      if (chamber_this==barrel_inner){//barrel inner
        tmp_rMin = (trans*OrigOfMdtInAmdbFrame).perp()/scale;
        tmp_rMax = tmp_rMin+muonStation->Rsize()/scale;
        if(rMin==0 || tmp_rMin < rMin)rMin = tmp_rMin;
        if(rMax==0 || tmp_rMax > rMax)rMax = tmp_rMax;
      }
 
      if (chamber_this==bee){//BEE
        tmp_rMin = (trans*OrigOfMdtInAmdbFrame).perp()/scale;
        tmp_rMax = tmp_rMin+muonStation->Rsize()/scale;
        if(rMin==0 || tmp_rMin < rMin)rMin = tmp_rMin;
        if(rMax==0 || tmp_rMax > rMax)rMax = tmp_rMax;
      }
      
    }
      }
      
      if (chamber==endcap_middle) { // endcap middle
    
    if (tgcFitResult.isSuccess) { // TGC data is properly read
      if (tgcFitResult.tgcMid1[3] < tgcFitResult.tgcMid2[3]) {
        zMin = tgcFitResult.tgcMid1[3];
        zMax = tgcFitResult.tgcMid2[3];
      } else {
        zMin = tgcFitResult.tgcMid2[3];
        zMax = tgcFitResult.tgcMid1[3];
      }
      
    } else { // Failed to read TGC data 
      
      zMin = sta_zMin;
      zMax = sta_zMax;
    }
      }
      else if (chamber==barrel_inner || chamber==bee) { //barrel inner || BEE
    float max_road = 50 /*muonRoad.MaxWidth(chamber)*/;
    find_barrel_road_dim(max_road,
                 muonRoad.aw[chamber][i_sector],
                 muonRoad.bw[chamber][i_sector],
                 rMin,rMax,
                 zMin,zMax);
      }else {// endcap inner,outer,ee
 
      zMin = sta_zMin;
      zMax = sta_zMax;
      }
      
      if (chamber!=barrel_inner && chamber!=bee){//Endcap chamber
        find_endcap_road_dim(muonRoad.rWidth[chamber][0],
                 muonRoad.aw[chamber][i_sector],
                 muonRoad.bw[chamber][i_sector],
                 zMin,zMax,
                 rMin, rMax);
      }
      
      ATH_MSG_DEBUG("...zMin/zMax/ty1/ty2=" << zMin << "/" << zMax << "/" << types[0] << "/" << types[1]);
      ATH_MSG_DEBUG("...rMin/rMax=" << rMin << "/" << rMax);
      
      find_eta_min_max(zMin, rMin, zMax, rMax, etaMin, etaMax);
      
      find_phi_min_max(muonRoad.phiRoI, phiMin, phiMax);
      
      ATH_MSG_DEBUG("...etaMin/etaMax/phiMin/phiMax=" << etaMin << "/" << etaMax << "/" << phiMin << "/" << phiMax);
      
      mdtRegion.zMin[chamber][i_sector] = zMin;
      mdtRegion.zMax[chamber][i_sector] = zMax;
      mdtRegion.rMin[chamber][i_sector] = rMin;
      mdtRegion.rMax[chamber][i_sector] = rMax;
      mdtRegion.etaMin[chamber][i_sector] = etaMin;
      mdtRegion.etaMax[chamber][i_sector] = etaMax;
      mdtRegion.phiMin[chamber][i_sector] = phiMin;
      mdtRegion.phiMax[chamber][i_sector] = phiMax;
      for(int i_type=0; i_type<2; i_type++) {
    int type = types[i_type];
    if( type == -1 ) continue;
    mdtRegion.chamberType[chamber][i_sector][i_type] = type;
      }
    } 
  }
  
  StatusCode sc = computePhi(p_roids, tgcFitResult, mdtRegion, muonRoad);
  if (sc.isFailure()) {
    ATH_MSG_ERROR("Error in comupting phi");
    return sc;
  }
  
  return StatusCode::SUCCESS;
}

initialize()

StatusCode TrigL2MuonSA::MdtRegionDefiner::initialize ( )

overridevirtual

Definition at line 19 of file MdtRegionDefiner.cxx.

{
  ATH_CHECK(m_muDetMgrKey.initialize());
  ATH_CHECK(m_idHelperSvc.retrieve());
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

prepareTgcPoints()

StatusCode TrigL2MuonSA::MdtRegionDefiner::prepareTgcPoints ( const TrigL2MuonSA::TgcHits & tgcHits )

private

Definition at line 462 of file MdtRegionDefiner.cxx.

{
   const double PHI_BOUNDARY = 0.2;
 
   // loop over TGC digits.
   unsigned int iHit;
   for (iHit = 0; iHit < tgcHits.size(); iHit++)
   {
      // Get the digit point.
      const TrigL2MuonSA::TgcHitData& hit = tgcHits[iHit];
 
      // reject width=0 hits
      const double ZERO_LIMIT = 1e-5;
      if( std::abs(hit.width) < ZERO_LIMIT ) continue;
 
      double w = 12.0 / hit.width / hit.width;
      if (hit.isStrip)
      {
     w *= hit.r * hit.r;
     double phi = hit.phi;
     if( phi < 0 && ( (M_PI+phi)<PHI_BOUNDARY) ) phi += M_PI*2;
     if      ( hit.sta < 3 ) { m_tgcStripMidPoints.push_back(TgcFit::Point(iHit + 1, hit.sta, hit.z, phi, w)); }
     else if ( hit.sta ==3 ) { m_tgcStripInnPoints.push_back(TgcFit::Point(iHit + 1, hit.sta, hit.z, phi, w)); }
      }
      else
      {
     if      ( hit.sta < 3 ) { m_tgcWireMidPoints.push_back(TgcFit::Point(iHit + 1, hit.sta, hit.z, hit.r, w)); }
     else if ( hit.sta ==3 ) { m_tgcWireInnPoints.push_back(TgcFit::Point(iHit + 1, hit.sta, hit.z, hit.r, w)); }
      }
   }
 
   return StatusCode::SUCCESS;
 
}

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setRpcGeometry()

void TrigL2MuonSA::MdtRegionDefiner::setRpcGeometry ( bool use_rpc )

inline

Definition at line 45 of file MdtRegionDefiner.h.

{m_use_rpc = use_rpc;};

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> TrigL2MuonSA::MdtRegionDefiner::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

Definition at line 76 of file MdtRegionDefiner.h.

{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

m_muDetMgrKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> TrigL2MuonSA::MdtRegionDefiner::m_muDetMgrKey {this, "DetectorManagerKey", "MuonDetectorManager", "Key of input MuonDetectorManager condition data"}

private

Definition at line 77 of file MdtRegionDefiner.h.

{this, "DetectorManagerKey", "MuonDetectorManager", "Key of input MuonDetectorManager condition data"}; 

m_tgcStripInnPoints

TrigL2MuonSA::TgcFit::PointArray TrigL2MuonSA::MdtRegionDefiner::m_tgcStripInnPoints

private

Definition at line 83 of file MdtRegionDefiner.h.

m_tgcStripMidPoints

TrigL2MuonSA::TgcFit::PointArray TrigL2MuonSA::MdtRegionDefiner::m_tgcStripMidPoints

private

Definition at line 81 of file MdtRegionDefiner.h.

m_tgcWireInnPoints

TrigL2MuonSA::TgcFit::PointArray TrigL2MuonSA::MdtRegionDefiner::m_tgcWireInnPoints

private

Definition at line 84 of file MdtRegionDefiner.h.

m_tgcWireMidPoints

TrigL2MuonSA::TgcFit::PointArray TrigL2MuonSA::MdtRegionDefiner::m_tgcWireMidPoints

private

Definition at line 82 of file MdtRegionDefiner.h.

m_use_rpc

bool TrigL2MuonSA::MdtRegionDefiner::m_use_rpc {true}

private

Definition at line 79 of file MdtRegionDefiner.h.

{true};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• MdtRegionDefiner.h
• MdtRegionDefiner.cxx