MuonIdCutTool Class Reference

Implementation of an IMuonIdCutTool. More...

#include <MuonIdCutTool.h>

Inheritance diagram for MuonIdCutTool:

Collaboration diagram for MuonIdCutTool:

Public Member Functions
	MuonIdCutTool (const std::string &, const std::string &, const IInterface *)
	default AlgTool constructor
virtual	~MuonIdCutTool ()=default
	destructor
StatusCode	initialize ()
	initialize method, method taken from bass-class AlgTool
virtual bool	isCut (Identifier ID) const
virtual bool	isCut (MuonCalib::MuonFixedId id) const
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 const InterfaceID &	interfaceID ()
	access to tool interface

Public Attributes
bool	m_cutStationRegion
bool	m_cutStationName
bool	m_cutSubstation
bool	m_cutEE
bool	m_cutEta
bool	m_cutPhi
std::vector< std::string >	m_EELList
std::vector< int >	m_mdtRegionList
std::vector< int >	m_cscRegionList
std::vector< int >	m_rpcRegionList
std::vector< int >	m_tgcRegionList
std::vector< int >	m_mdtStationNameList
std::vector< int >	m_cscStationNameList
std::vector< int >	m_rpcStationNameList
std::vector< int >	m_tgcStationNameList
std::vector< int >	m_mdtMultilayerList
std::vector< int >	m_rpcDoubletRList
std::vector< int >	m_rpcGasGapList
std::vector< int >	m_tgcGasGapList
std::vector< int >	m_mdtBarEtaList
std::vector< int >	m_mdtEndEtaList
std::vector< int >	m_mdtSectorList
std::vector< int >	m_rpcEtaList
std::vector< int >	m_rpcSectorList
std::vector< int >	m_cscEtaList
std::vector< int >	m_cscSectorList
std::vector< int >	m_tgcEtaList
std::vector< int >	m_tgcEndPhiList
std::vector< int >	m_tgcForPhiList

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
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
static int	FindSector (unsigned int staName, unsigned int staPhi)

Private Attributes
ToolHandle< MuonCalib::IIdToFixedIdTool >	m_idToFixedIdTool {this,"IdToFixedIdTool","MuonCalib::IdToFixedIdTool","tool to assist with Identifiers"}
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
std::vector< int >	m_EELeta
std::vector< int >	m_EELsector
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

Implementation of an IMuonIdCutTool.

For more details look at the mainpage of this package.

Definition at line 28 of file MuonIdCutTool.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

MuonIdCutTool()

MuonIdCutTool::MuonIdCutTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

default AlgTool constructor

Definition at line 13 of file MuonIdCutTool.cxx.

                                                                                       :  
  AthAlgTool(t,n,p) {
  declareInterface<IMuonIdCutTool>(this);
  
  declareProperty("CutStationRegion",m_cutStationRegion = false ); //0 inner, 1 extra(BEE), 2 middle, 3 outer
  declareProperty("CutStationName",m_cutStationName = true ); //integer which maps to BIL etc.
  declareProperty("CutSubstation",m_cutSubstation = false ); //do you want to cut on gas-gap or multilayer
  declareProperty("CutEta",m_cutEta = false );
  declareProperty("CutPhi",m_cutPhi = false ); 
  declareProperty("CutEE",m_cutEE = false ); //cut all EES, leave some EEL
 
 
  declareProperty("CutMdtRegionList",m_mdtRegionList );
  declareProperty("CutCscRegionList",m_cscRegionList );
  declareProperty("CutRpcRegionList",m_rpcRegionList );
  declareProperty("CutTgcRegionList",m_tgcRegionList );
  declareProperty("CutMdtStationNameList",m_mdtStationNameList );//cut these station names
  declareProperty("CutCscStationNameList",m_cscStationNameList );
  declareProperty("CutRpcStationNameList",m_rpcStationNameList );
  declareProperty("CutTgcStationNameList",m_tgcStationNameList );
  declareProperty("CutMdtMultilayerList",m_mdtMultilayerList );//entries in these lists are matched 
  declareProperty("CutRpcDoubletRList",m_rpcDoubletRList );//to entries in the stationName list.
  declareProperty("CutRpcGasGapList",m_rpcGasGapList );//the size of each list should be the same
  declareProperty("CutTgcGasGapList",m_tgcGasGapList );
  declareProperty("EELList",m_EELList ); //eta/sector to keep for EEL
 
 
  //note that the following properties are the eta/phi sectors too keep
  declareProperty("MdtBarrelEtaList",m_mdtBarEtaList );// -8 to 8, 0 would refer to eta = 0
  declareProperty("MdtEndcapEtaList",m_mdtEndEtaList );// -6 to 6, abs value increases with |R|
  declareProperty("MdtSectorList",m_mdtSectorList );// 1 to 8 for the whole detector, 1 points in +x
  
  declareProperty("RpcEtaList",m_rpcEtaList );// -8 to 8, 0 would refer to eta = 0
  declareProperty("RpcSectorList",m_rpcSectorList );// 1 to 8 for the whole detector, 1 points in +x
 
  declareProperty("CscEtaList",m_cscEtaList );// 1 is the only value
  declareProperty("CscSectorList",m_cscSectorList );// 1 to 8 for the whole detector, 1 points in +x
 
  //tgcs go by a different eta/phi numbering scheme and so must be cut separately
  declareProperty("TgcEtaList",m_tgcEtaList );// -5 to 5, [roughly] matches the endcap mdt naming scheme
  declareProperty("TgcEndcapPhiList",m_tgcEndPhiList );// 1 to 48 endcap
  declareProperty("TgcForwardPhiList",m_tgcForPhiList );// 1 to 24 forward
 
 
  //The cuts are independent, but if you have both cutEta = true and cutPhi = true make
  //sure to set either both eta and phi or neither lists for a given technology, otherwise, the program will
  //cut the whole technology
 
}

~MuonIdCutTool()

virtual MuonIdCutTool::~MuonIdCutTool ( )

virtualdefault

destructor

Member Function Documentation

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

FindSector()

int MuonIdCutTool::FindSector ( unsigned int staName, unsigned int staPhi )

staticprivate

Definition at line 365 of file MuonIdCutTool.cxx.

                                                                       {
 
  int sector=-1;
  
  //This strange looking array specifies whether the station is large or small
  //999 specifies a number not used, or a tgc
  //station name maps to BIL,EOS,etc
  int isStationNameLarge[53] = {1,0,1,0,1,0,0,1,0,0,0,0,999,1,1,0,999,1,0,999,1,0,999,999,999,999,999,999,999,999,999,999,999,999,999,999,999,999,999,999,999,999,999,999,999,999,999,999,999,0,0,1,1};
  
  if (staName < 53){
    sector = staPhi*2 - isStationNameLarge[staName];
  }
  
  return sector;
  
}

initialize()

StatusCode MuonIdCutTool::initialize

(

)

initialize method, method taken from bass-class AlgTool

Definition at line 63 of file MuonIdCutTool.cxx.

                                     {
  ATH_CHECK( m_idToFixedIdTool.retrieve() );
  ATH_CHECK( m_idHelperSvc.retrieve() );
  
  if (!m_cutStationName && !m_cutStationRegion && !m_cutEta && !m_cutPhi && !m_cutEE){
    ATH_MSG_WARNING( "MuonIdCutTool invoked with no cuts performed"   );
  }
 
  //interpret EEL cuts
  int max = m_EELList.size();
  
  for(int i=0;i<max;i++){
    std::string_view cut = m_EELList[i];
    ATH_MSG_DEBUG( "EEL String: "  << cut  );
    size_t length = cut.size();
    size_t loc = cut.find('/');
    if (loc!=std::string::npos){
      std::string_view etaString = cut.substr(0,loc);
      std::string_view sectorString = cut.substr(loc+1,length-loc-1);
      int eta =   CxxUtils::atoi(etaString);
      int sector =  CxxUtils::atoi(sectorString);
 
      ATH_MSG_DEBUG( "EEL eta/phi string: "<< etaString << " " << sectorString  );
      ATH_MSG_DEBUG( "EEL eta/phi int: "<< eta << " " << sector  );
 
  
      if(std::abs(eta) > 0 && std::abs(eta) < 3 && sector > 0 && sector < 17){
    m_EELeta.push_back(eta);
    m_EELsector.push_back(sector);
      
      } else {
    ATH_MSG_WARNING( "Improper EEL Cut Selected, this cut is skipped"   );
      }
 
    } else {
      ATH_MSG_WARNING( "Improperly formated EEL Cut Selected, this cut is skipped"   );
    }
  }
 
  for(unsigned int i=0; i < m_EELeta.size();i++){
    ATH_MSG_DEBUG( "Eta: " << m_EELeta[i] << " Sector: " << m_EELsector[i]  );
  }
 
  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.

interfaceID()

const InterfaceID & IMuonIdCutTool::interfaceID ( )

inlinestaticinherited

access to tool interface

Definition at line 34 of file IMuonIdCutTool.h.

{
  return IID_IMuonIdCutTool;
}

isCut() [1/2]

bool MuonIdCutTool::isCut ( Identifier ID ) const

virtual

Implements IMuonIdCutTool.

Definition at line 109 of file MuonIdCutTool.cxx.

                                             { //false indicates all cuts are passed
  
  //some checks to see if the tool is configured in a state that makes sense 
  if (m_cutStationName && m_cutStationRegion){
    ATH_MSG_WARNING( "MuonIdCutTool invoked with both Region Cuts and Station name cuts.Are you sure this is what you want?");
  }
 
  if (m_cutSubstation){
    if ((m_mdtMultilayerList.size() != m_mdtStationNameList.size()) || (m_tgcGasGapList.size() != m_tgcStationNameList.size()) ){
      ATH_MSG_WARNING( "Station and Substation cuts lists should match in length, no cut perfomed"   );
      return false;
    }
    else if ((m_rpcDoubletRList.size() != m_rpcStationNameList.size()) || ((m_rpcGasGapList.size() != m_rpcStationNameList.size()) && !m_rpcGasGapList.empty() )){
      ATH_MSG_WARNING( "Station and Substation cuts lists should match in length, no cut perfomed"   );
      return false;
    }
  }
 
  std::vector<int> cutList; //this will chose the correct cut list (StationName or Station Region)
 
  unsigned int staName = m_idHelperSvc->stationName(ID);
  unsigned int staPhi = m_idHelperSvc->stationPhi(ID);
 
  int sector = FindSector(staName,staPhi);
 
  //Routine for cutting all EES and some EEL chambers
  if(m_cutEE && staName == 15) return true;
  if(m_cutEE && staName == 14){
    int listSize = m_EELeta.size();
    for (int i=0;i<listSize;i++){
      if(m_EELeta[i]==(m_idHelperSvc->stationEta(ID)) && m_EELsector[i]==sector) break;
      if(i==(listSize-1)) return true; //if fails last entry, cut = true
    }
  }
 
  //Routine for cutting on Station Region
 
  if (m_cutStationRegion){ 
    if (m_idHelperSvc->isMdt(ID)){
      cutList = m_mdtRegionList;
    }
    else if (m_idHelperSvc->isCsc(ID)){
      cutList = m_cscRegionList;
    } 
    else if (m_idHelperSvc->isRpc(ID)){
      cutList = m_rpcRegionList;
    } 
    else if (m_idHelperSvc->isTgc(ID)){
      cutList = m_tgcRegionList;
    } 
    else{
      ATH_MSG_ERROR( "Failure to determine technology type of ID#, returning false"  );
      return false;
    }
    
    int listSize = cutList.size();
    for (int i=0; i<listSize;i++){                      
      ATH_MSG_DEBUG( "Region " << m_idHelperSvc->stationRegion(ID) 
                     << " compared with " << cutList[i]  );
      if( cutList[i] == m_idHelperSvc->stationRegion(ID)){
    ATH_MSG_DEBUG( "Return True"  );
    return true;
      }
    }
    ATH_MSG_DEBUG( "Passes Region Cut"  );
  }
 
    
  //Routine for cutting on Station Name and optional sub-region cuts
    
  
  if (m_cutStationName){ 
    if (m_idHelperSvc->isMdt(ID)){
      cutList = m_mdtStationNameList;
    }
    else if (m_idHelperSvc->isCsc(ID)){
      cutList = m_cscStationNameList;
    } 
    else if (m_idHelperSvc->isRpc(ID)){
      cutList = m_rpcStationNameList;
    } 
    else if (m_idHelperSvc->isTgc(ID)){
      cutList = m_tgcStationNameList;
    } 
    else{
      ATH_MSG_ERROR( "Failure to determine technology type of ID#, returning false"  );
      return false;
    }
 
    int listSize = cutList.size();
    for (int i=0; i<listSize;i++){
      ATH_MSG_DEBUG( "Station Name " << m_idHelperSvc->stationName(ID) <<  " compared with " 
                     <<cutList[i]    );
      if( cutList[i] == m_idHelperSvc->stationName(ID)){
    if (!m_cutSubstation){
      return true;
    }
    
    else {  //proceed with more specific cuts
 
      if (m_idHelperSvc->isMdt(ID)){
        ATH_MSG_DEBUG( "MDT multilayer " <<m_idHelperSvc->mdtIdHelper().multilayer(ID)
                           <<  " compared with " << m_mdtMultilayerList[i]   );
        if(m_mdtMultilayerList[i] == m_idHelperSvc->mdtIdHelper().multilayer(ID))
          return true;
      }
 
 
      else if (m_idHelperSvc->isRpc(ID)){
        ATH_MSG_DEBUG( "RPC doublet R " <<m_idHelperSvc->rpcIdHelper().doubletR(ID)
                           <<  " compared with " << m_rpcDoubletRList[i]   );
        if( m_rpcDoubletRList[i] == m_idHelperSvc->rpcIdHelper().doubletR(ID) ){
          if (m_rpcGasGapList.empty()){
        return true;
          }
          else {
        ATH_MSG_DEBUG( "RPC gasgap " <<m_idHelperSvc->rpcIdHelper().gasGap(ID)
                               <<  " compared with " << m_rpcGasGapList[i]   );
        if (m_rpcGasGapList[i] == m_idHelperSvc->rpcIdHelper().gasGap(ID))
          return true;
          }
              
        }
      }
      
          
      else if (m_idHelperSvc->isTgc(ID)){
        ATH_MSG_DEBUG( "TGC gasgap " <<m_idHelperSvc->tgcIdHelper().gasGap(ID)
                           <<  " compared with " << m_tgcGasGapList[i]   );
        if (m_tgcGasGapList[i] == m_idHelperSvc->tgcIdHelper().gasGap(ID))
          return true;
      }
          
          
    } //end sub-region cuts
      } //end if statement checking station name
    } //end station name loop
  } //end if m_cutStationName
  
  
  //Routine for cutting on eta and phi
  //this routine should always be last because its the only one that
  //ever returns false
  
  if (m_cutEta || m_cutPhi){ 
    
    std::vector<int> genEtaList; //general eta list (can be tgc list)
    std::vector<int> genPhiList; //general phi list (can be tgc list)
    int etaListSize;
    int phiListSize;
    int phi; //this variable is the phi index for tgcs, the sector for everyone else
    unsigned int staName = m_idHelperSvc->stationName(ID);
    unsigned int staPhi = m_idHelperSvc->stationPhi(ID);
    int sector = FindSector(staName,staPhi);
    phi = sector;
    
    ATH_MSG_DEBUG( "Phi Station is " << staPhi
                   << " and Station name is " << staName  );
    
    ATH_MSG_DEBUG( "Phi Sector is " << sector  );
    
    //Is it tgc?
    if (m_idHelperSvc->isTgc(ID)){
      //If no cuts specified, don't cut anything
      if (m_tgcEtaList.empty() && m_tgcEndPhiList.empty() && m_tgcForPhiList.empty())
    return false;
      genEtaList = m_tgcEtaList;
      phi = m_idHelperSvc->stationPhi(ID);
      //Is it forward?
      if (staName == 41 || staName == 43 || staName == 45 || staName == 47)
    genPhiList = m_tgcForPhiList;
      else
    genPhiList = m_tgcEndPhiList;
    }
    
    
    //mdt?
    else if(m_idHelperSvc->isMdt(ID)){
      //If no cuts specified, don't cut anything
      if (m_mdtSectorList.empty() && m_mdtEndEtaList.empty() && m_mdtBarEtaList.empty())
    return false;
      genPhiList = m_mdtSectorList;
      if (m_idHelperSvc->isEndcap(ID)) {
        genEtaList = m_mdtEndEtaList;
      } else {
        genEtaList = m_mdtBarEtaList;
      }
  }
    
    //rpc?
    else if(m_idHelperSvc->isRpc(ID)){
      //If no cuts specified, don't cut anything
      if (m_rpcSectorList.empty() && m_rpcEtaList.empty())
    return false;
      genPhiList = m_rpcSectorList;
      genEtaList = m_rpcEtaList;
    }
    
    //csc?
    else if(m_idHelperSvc->isCsc(ID)){
      //If no cuts specified, don't cut anything
      if (m_cscSectorList.empty() && m_cscEtaList.empty())
    return false;
      genPhiList = m_cscSectorList;
      genEtaList = m_cscEtaList;
    }
    
    etaListSize = genEtaList.size();
    phiListSize = genPhiList.size();
    
    bool etapass = true;
    bool phipass = true;
    
    if(m_cutEta){
      etapass = false;
      for (int i=0; i<etaListSize;i++){
    ATH_MSG_DEBUG( "Eta Station " << m_idHelperSvc->stationEta(ID) 
                       << " compared with list to keep " << genEtaList[i]  );
    if( genEtaList[i] == m_idHelperSvc->stationEta(ID))
      etapass = true;
      }
    }
    
    if(m_cutPhi){
      phipass = false;
      
      for (int i=0; i<phiListSize;i++){
    ATH_MSG_DEBUG( "Phi Station " << phi 
                       << " compared with list to keep " << genPhiList[i]  );
    if( genPhiList[i] == phi)
      phipass = true;
      }
    }
    
    if (!etapass || !phipass) //if eta or phi fail it is cut
      return true;
    
  }
  
  
  
  
  return false; //keep the event if none of the cuts removed the event
}

isCut() [2/2]

bool MuonIdCutTool::isCut ( MuonCalib::MuonFixedId id ) const

virtual

Implements IMuonIdCutTool.

Definition at line 357 of file MuonIdCutTool.cxx.

                                                         {
//  std::cout << "testing if IdCuts called" << std::endl;
Identifier ID = m_idToFixedIdTool->fixedIdToId(mfid);
bool iscut = MuonIdCutTool::isCut(ID);
return iscut;
}

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.

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

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_cscEtaList

std::vector<int> MuonIdCutTool::m_cscEtaList

Definition at line 72 of file MuonIdCutTool.h.

m_cscRegionList

std::vector<int> MuonIdCutTool::m_cscRegionList

Definition at line 53 of file MuonIdCutTool.h.

m_cscSectorList

std::vector<int> MuonIdCutTool::m_cscSectorList

Definition at line 73 of file MuonIdCutTool.h.

m_cscStationNameList

std::vector<int> MuonIdCutTool::m_cscStationNameList

Definition at line 58 of file MuonIdCutTool.h.

m_cutEE

bool MuonIdCutTool::m_cutEE

Definition at line 47 of file MuonIdCutTool.h.

m_cutEta

bool MuonIdCutTool::m_cutEta

Definition at line 48 of file MuonIdCutTool.h.

m_cutPhi

bool MuonIdCutTool::m_cutPhi

Definition at line 49 of file MuonIdCutTool.h.

m_cutStationName

bool MuonIdCutTool::m_cutStationName

Definition at line 45 of file MuonIdCutTool.h.

m_cutStationRegion

bool MuonIdCutTool::m_cutStationRegion

Definition at line 44 of file MuonIdCutTool.h.

m_cutSubstation

bool MuonIdCutTool::m_cutSubstation

Definition at line 46 of file MuonIdCutTool.h.

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_EELeta

std::vector<int> MuonIdCutTool::m_EELeta

private

Definition at line 87 of file MuonIdCutTool.h.

m_EELList

std::vector<std::string> MuonIdCutTool::m_EELList

Definition at line 51 of file MuonIdCutTool.h.

m_EELsector

std::vector<int> MuonIdCutTool::m_EELsector

private

Definition at line 88 of file MuonIdCutTool.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> MuonIdCutTool::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

Definition at line 85 of file MuonIdCutTool.h.

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

m_idToFixedIdTool

ToolHandle<MuonCalib::IIdToFixedIdTool> MuonIdCutTool::m_idToFixedIdTool {this,"IdToFixedIdTool","MuonCalib::IdToFixedIdTool","tool to assist with Identifiers"}

private

Definition at line 83 of file MuonIdCutTool.h.

{this,"IdToFixedIdTool","MuonCalib::IdToFixedIdTool","tool to assist with Identifiers"};

m_mdtBarEtaList

std::vector<int> MuonIdCutTool::m_mdtBarEtaList

Definition at line 67 of file MuonIdCutTool.h.

m_mdtEndEtaList

std::vector<int> MuonIdCutTool::m_mdtEndEtaList

Definition at line 68 of file MuonIdCutTool.h.

m_mdtMultilayerList

std::vector<int> MuonIdCutTool::m_mdtMultilayerList

Definition at line 62 of file MuonIdCutTool.h.

m_mdtRegionList

std::vector<int> MuonIdCutTool::m_mdtRegionList

Definition at line 52 of file MuonIdCutTool.h.

m_mdtSectorList

std::vector<int> MuonIdCutTool::m_mdtSectorList

Definition at line 69 of file MuonIdCutTool.h.

m_mdtStationNameList

std::vector<int> MuonIdCutTool::m_mdtStationNameList

Definition at line 57 of file MuonIdCutTool.h.

m_rpcDoubletRList

std::vector<int> MuonIdCutTool::m_rpcDoubletRList

Definition at line 63 of file MuonIdCutTool.h.

m_rpcEtaList

std::vector<int> MuonIdCutTool::m_rpcEtaList

Definition at line 70 of file MuonIdCutTool.h.

m_rpcGasGapList

std::vector<int> MuonIdCutTool::m_rpcGasGapList

Definition at line 64 of file MuonIdCutTool.h.

m_rpcRegionList

std::vector<int> MuonIdCutTool::m_rpcRegionList

Definition at line 54 of file MuonIdCutTool.h.

m_rpcSectorList

std::vector<int> MuonIdCutTool::m_rpcSectorList

Definition at line 71 of file MuonIdCutTool.h.

m_rpcStationNameList

std::vector<int> MuonIdCutTool::m_rpcStationNameList

Definition at line 59 of file MuonIdCutTool.h.

m_tgcEndPhiList

std::vector<int> MuonIdCutTool::m_tgcEndPhiList

Definition at line 76 of file MuonIdCutTool.h.

m_tgcEtaList

std::vector<int> MuonIdCutTool::m_tgcEtaList

Definition at line 75 of file MuonIdCutTool.h.

m_tgcForPhiList

std::vector<int> MuonIdCutTool::m_tgcForPhiList

Definition at line 77 of file MuonIdCutTool.h.

m_tgcGasGapList

std::vector<int> MuonIdCutTool::m_tgcGasGapList

Definition at line 65 of file MuonIdCutTool.h.

m_tgcRegionList

std::vector<int> MuonIdCutTool::m_tgcRegionList

Definition at line 55 of file MuonIdCutTool.h.

m_tgcStationNameList

std::vector<int> MuonIdCutTool::m_tgcStationNameList

Definition at line 60 of file MuonIdCutTool.h.

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:

• MuonIdCutTool.h
• MuonIdCutTool.cxx