TrigL2MuonSA::RpcPatFinder Class Reference

#include <RpcPatFinder.h>

Inheritance diagram for TrigL2MuonSA::RpcPatFinder:

Collaboration diagram for TrigL2MuonSA::RpcPatFinder:

Public Member Functions
void	addHit (const std::string &stationName, int stationEta, bool measuresPhi, unsigned int gasGap, unsigned int doubletR, double gPosX, double gPosY, double gPosZ, TrigL2MuonSA::RpcLayerHits &rpcLayerHits) const
bool	findPatternEta (std::array< std::reference_wrapper< double >, 3 > &result_aw, std::array< std::reference_wrapper< double >, 3 > &result_bw, const TrigL2MuonSA::RpcLayerHits &rpcLayerHits) const
bool	findPatternPhi (double &phi_middle, double &phi_outer, const TrigL2MuonSA::RpcLayerHits &rpcLayerHits) 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

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
bool	deltaOK (int l1, int l2, double x1, double x2, int isphi, double &delta) const
double	calibR (const std::string &stationName, double R, double Phi) const
void	abcal (const std::bitset< 8 > &result_pat, const std::array< size_t, 8 > &index, std::array< std::reference_wrapper< double >, 3 > &aw, std::array< std::reference_wrapper< double >, 3 > &bw, const TrigL2MuonSA::RpcLayerHits &rpcLayerHits) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
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 38 of file RpcPatFinder.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

abcal()

void TrigL2MuonSA::RpcPatFinder::abcal ( const std::bitset< 8 > & result_pat, const std::array< size_t, 8 > & index, std::array< std::reference_wrapper< double >, 3 > & aw, std::array< std::reference_wrapper< double >, 3 > & bw, const TrigL2MuonSA::RpcLayerHits & rpcLayerHits ) const

private

Calculate inner and middle coefficients

Inner

Middle

Calculate outer coefficients

Definition at line 351 of file RpcPatFinder.cxx.

                                                                                          {
    const float ZERO_LIMIT = 1.e-5;
    const std::vector<std::vector<double>>& rpc_R {rpcLayerHits.hits_in_layer_R};
    const std::vector<std::vector<double>>& rpc_Z {rpcLayerHits.hits_in_layer_Z};
 
    // doublet companion                                    
    auto getCompanion = [](const int& l) -> int {
        return (l%2==0) ? l+1 : l-1;
    };
 
    auto getAvgRZ= [&rpc_R, &rpc_Z, &result_pat, &index](double& R, double& Z, int l, int companion) -> void {
        const auto idxAtl = index.at(l);
        const auto idxAtComp = index.at(companion);
        if (result_pat.test(companion)){
            R = (rpc_R.at(l).at(idxAtl) + rpc_R.at(companion).at(idxAtComp)) / 2.0;
            Z = (rpc_Z.at(l).at(idxAtl) + rpc_Z.at(companion).at(idxAtComp)) / 2.0;
            return;
        }
        R = rpc_R.at(l).at(idxAtl);
        Z = rpc_Z.at(l).at(idxAtl);
    };

    int l1 {4}, l2 {0};
    double R1{0}, R2{0}, Z1{0}, Z2{0};
    for(int i=0; i<4; i++){
        if(!result_pat.test(i)) continue;
        l1 = std::min(l1, i);
        l2 = std::max(l2, i);
    }
    const int comp1{getCompanion(l1)}, comp2{getCompanion(l2)};
    if (l1 != 4 and l1 != l2 and l2 != comp1){// we have two hits in BM and not in the same doublet 
        
        getAvgRZ(R1, Z1, l1, comp1);
        getAvgRZ(R2, Z2, l2, comp2);

        if(((result_pat & std::bitset<8>("00001111")).count() > 3) and std::abs(Z2-Z1) > ZERO_LIMIT){
 
            double theta_m {std::atan2(R1, Z1)};
            double theta_t {std::atan2(R2-R1, Z2-Z1)};
            double theta_f {(theta_m+theta_t)/2.};
 
            aw[0].get() = std::tan(theta_f);
            bw[0].get() = R1 - Z1*aw[0].get();
 
        }else{
            aw[0].get() = R1/Z1;
            bw[0].get() = 0.;
        }
        
        if (std::abs(Z2-Z1) > ZERO_LIMIT){
            aw[1].get() = (R2-R1)/(Z2-Z1);
            bw[1].get() = R2 - Z2*aw[1].get();
        }
        else{// if hits have very close z, we use only the earlier hit
            aw[1].get() = R1/Z1;
            bw[1].get() = 0.;
        }
    }
    else if (l1 != 4){// either we have two hits in the same doublet or only one hit
        getAvgRZ(R1, Z1, l1, comp1);
        aw[0].get() = R1/Z1;
        bw[0].get() = 0.;
        aw[1].get() = aw[0].get();
        bw[1].get() = 0.;
 
    }// if no hits in BM, we will extrapolate the inner and BM slope using the first hit in BO

    int l3 = 8, l4 = 0;
    double R3{0}, R4{0}, Z3{0}, Z4{0};
    for(int i=2; i<8; i++){
        if(!result_pat.test(i)) continue;
        l3 = std::min(l3, i);
        l4 = std::max(l4, i);
    }
    const int comp3{getCompanion(l3)}, comp4{getCompanion(l4)};
    if ( l3 != 8 and l3 != l4 and l4 != comp3){
 
        getAvgRZ(R3, Z3, l3, comp3);
        getAvgRZ(R4, Z4, l4, comp4);
 
        if (std::abs(Z4-Z3) > ZERO_LIMIT){
            aw[2].get() = (R4-R3)/(Z4-Z3);
            bw[2].get() = R4 - Z4*aw[2].get();
        }
        else{// hits with very close Z, we use onl one hit.
            aw[2].get() = R4/Z4;
            bw[2].get() = 0.;
        }
    }
    else if (l3 != 8){ // we have only one hit or they are in the same doublet
        getAvgRZ(R3, Z3, l3, comp3);
        aw[2].get() = R3/Z3;
        bw[2].get() = 0.;
    }// if no hits in outer layers, we will extrapolate the outer slope using the last hit in BM
 
    if (std::abs(aw[0].get()) < ZERO_LIMIT){    // if no hits in BM, we use the first in in BO
        getAvgRZ(R3, Z3, l3, comp3);
        aw[0].get() =  R3/Z3;
        aw[1].get() = aw[0].get();
    }
    if (std::abs(aw[2].get()) < ZERO_LIMIT){    // if no hits in outer layers, we use the last in BM
        getAvgRZ(R2, Z2, l2, comp2);
        aw[2].get() = R2/Z2;
    }
                                    
 
}//abcal()

addHit()

void TrigL2MuonSA::RpcPatFinder::addHit	(	const std::string &	stationName,
		int	stationEta,
		bool	measuresPhi,
		unsigned int	gasGap,
		unsigned int	doubletR,
		double	gPosX,
		double	gPosY,
		double	gPosZ,
		TrigL2MuonSA::RpcLayerHits &	rpcLayerHits ) const

Definition at line 18 of file RpcPatFinder.cxx.

                                                                                      {
  
  int ilay=0;
  // BO 
  if (stationName.substr(0,2)=="BO") ilay=4;
  // doubletR
  ilay+=2*(doubletR-1);
  // BML7 special chamber with 1 RPC doublet (doubletR=1 but RPC2) :
  if (stationName.substr(0,3)=="BML" && stationEta==7) ilay+=2;
  // gasGap
  ilay+=gasGap-1;
 
  double R=std::sqrt(gPosX*gPosX+gPosY*gPosY);
  const double Phi=std::atan2(gPosY,gPosX);
 
  if (!measuresPhi){
    // if eta measurement then save Z/R
    R = calibR(stationName,R, Phi);  
    double x=gPosZ/R;
    rpcLayerHits.hits_in_layer_eta.at(ilay).push_back(x);
    rpcLayerHits.hits_in_layer_R.at(ilay).push_back(R);//mod!
    rpcLayerHits.hits_in_layer_Z.at(ilay).push_back(gPosZ);//mod!
   }else{
    // if phi measurement then save phi
    rpcLayerHits.hits_in_layer_phi.at(ilay).push_back(Phi);
  }
}

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 )
{
}

calibR()

double TrigL2MuonSA::RpcPatFinder::calibR ( const std::string & stationName, double R, double Phi ) const

private

Definition at line 322 of file RpcPatFinder.cxx.

                                                                                               {
  double DeltaPhi, temp_phi;
  double calibPhi = std::acos(std::cos(Phi)); // 0 < Phi < 2PI
  
  if(std::string::npos != stationName.rfind('L')){//For Large , SP
    DeltaPhi= 999; temp_phi=9999;
    for(int inum=0;inum < 8;inum++){
      temp_phi = std::abs((inum * M_PI/4.0 )- calibPhi);
      if(temp_phi < DeltaPhi)      DeltaPhi = temp_phi;
    }
  }else if(std::string::npos != stationName.rfind('S') ||
       std::string::npos != stationName.rfind('F') ||
       std::string::npos != stationName.rfind('G')   ){
    DeltaPhi= 999; temp_phi=9999;
 
    for(int inum=0;inum < 8;inum++){
      temp_phi = std::abs(inum *(M_PI/4.0 )+(M_PI/8.0) - calibPhi);
      if(temp_phi < DeltaPhi)      DeltaPhi = temp_phi;
    }//for end
  }else return R;
 
  double calibR = R *std::cos(DeltaPhi);
  
  return calibR;
}//calbR()

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

deltaOK()

bool TrigL2MuonSA::RpcPatFinder::deltaOK ( int l1, int l2, double x1, double x2, int isphi, double & delta ) const

private

Definition at line 249 of file RpcPatFinder.cxx.

                                                                                                           {
  
  
  // ROAD tuned for ~20 GeV 
  /*
  double delta_gasgap_eta = 0.004;
  double delta_lowpt_eta = 0.005;
  double delta_highpt_eta = 0.012;
  double delta_feet_eta = 0.02;
 
  double delta_gasgap_phi = 0.004;
  double delta_lowpt_phi = 0.005;
  double delta_highpt_phi = 0.008;
  double delta_feet_phi = 0.02;
  */
 
  //OPEN road 
 
  const double delta_gasgap_eta = 0.01;
  const double delta_lowpt_eta = 0.05;
  const double delta_highpt_eta = 0.1;
  const double delta_feet_eta = 0.05;
 
  const double delta_gasgap_phi = 0.01;
  const double delta_lowpt_phi = 0.03;
  const double delta_highpt_phi = 0.04;
  const double delta_feet_phi = 0.03;
 
  // calculate delta-eta or delta-phi 
  if(isphi) delta=std::abs(std::acos(std::cos(x2-x1)));
  else delta=std::abs(x2-x1); 
 
  double delta_max=0;
  if (l1>l2) {
    int tmp=l2;
    l2=l1;
    l1=tmp;
  }
  // calculate delta_max
  if (isphi){
    if (l2-l1==1&&(l1==0||l1==2||l1==4||l1==6)){
      delta_max=delta_gasgap_phi;
    } else if (l1<2&&l2<4) {
      delta_max=delta_lowpt_phi;
    }else if (l1<4&&l2>=4) {
      delta_max=delta_highpt_phi;
    }else if (l1<6&&l1>=4&&l2>=6) {
      delta_max=delta_feet_phi;
    }
  } else {
    if (l2-l1==1&&(l1==0||l1==2||l1==4||l1==6)){
      delta_max=delta_gasgap_eta;
    } else if (l1<2&&l2>=2&&l2<4) {
      delta_max=delta_lowpt_eta;
    }else if (l1<4&&l2>=4) {
      delta_max=delta_highpt_eta;
    }else if (l1<6&&l1>=4&&l2>=6) {
      delta_max=delta_feet_eta;
    }
  }
 
  // evaluate the result
 
  bool OK=false;
  if (delta<delta_max) OK=true;
 
  return OK;
  
}

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

findPatternEta()

bool TrigL2MuonSA::RpcPatFinder::findPatternEta	(	std::array< std::reference_wrapper< double >, 3 > &	result_aw,
		std::array< std::reference_wrapper< double >, 3 > &	result_bw,
		const TrigL2MuonSA::RpcLayerHits &	rpcLayerHits ) const

Definition at line 57 of file RpcPatFinder.cxx.

                                                               {
  
    const std::vector<std::vector<double>>&  rpc_x {rpcLayerHits.hits_in_layer_eta};
 
    int  layer_end {5};
    if(rpc_x.at(6).size()+rpc_x.at(7).size() >0) layer_end = 7;//special "feet" towers
 
    // reset parameters
    std::bitset<8> result_pat{};
    double result_dMM{9999}, result_dMO{9999};
    int nHits_pat{0};
    std::array<size_t, 8> result_index{};
 
    // Loop on start layer
    for (int l_start=0; l_start<layer_end; l_start++){
        // Loop on hits of start layer, for each hit try a new pattern
        for (size_t i_start = 0; i_start < rpc_x.at(l_start).size(); ++i_start){
 
            // Initialize a new pattern
            int nHits=1;
            std::bitset<8> pat (1<<l_start); // bit pattern of hit layers
            std::array<size_t, 8> index {};
            index[l_start] = i_start;
            double dMO{9999}; // lowest deltaX between two consecutive hits, when having at least one of the two hit in BO
            double dMM{9999}; // lowest deltaX between two consecutive hits, when having both hits in BM, or both in BO (but different doublets)
 
            int current_l = l_start;
            double current_x = rpc_x.at(l_start).at(i_start); // set current_x to the starting hit
 
            // ----- add compatible hits in other layers ----//
            // loop on test layers:
            for (int l_test=l_start+1; l_test<=layer_end; l_test++){
                double min_delta {999};   // min deltaX in this test laeyr
                const std::vector<double>& test_layer_hits {rpc_x.at(l_test)};
 
                for (size_t i_test = 0; i_test < test_layer_hits.size(); ++i_test){
                    double delta=-1;
                    // check if within the road
                    if (deltaOK(current_l,l_test,current_x, test_layer_hits.at(i_test),false,delta)){
                        // if closest hit we keep it as best hit for this test layer
                        if (delta < min_delta) {
                            min_delta = delta;
                            index[l_test] = i_test;
                        }
                    }
                }
                if (min_delta < 998){   //we found at least one hit in the window
                    current_l = l_test; 
                    current_x = test_layer_hits.at(index[l_test]);
                    nHits+=1;
                    pat.set(l_test);
                    dMO = (l_start<4 and l_test>=4) ? std::min(dMO, min_delta) : dMO;
                    dMM = (l_start<2 and l_test>=2 and l_test<4) or (l_start>=4 and l_start<5 and l_test>=6) ? std::min(dMM, min_delta) : dMM;
                }
            }//for l_test
 
            // if longest pattern found, update result
            if (nHits>nHits_pat) { 
                nHits_pat=nHits;
                result_pat=pat;
                result_dMO=dMO; 
                result_dMM=dMM; 
                result_index=index;
            }else if (nHits==nHits_pat) { 
                // if same lenght but smallest dMM/dMO, update result
                if (dMM<result_dMM or (dMM==result_dMM and dMO<result_dMO)){
                    result_pat=pat;
                    result_dMO=dMO;
                    result_dMM=dMM;
                    result_index=index;
                }
            }
        }//for i_start
    }//for l_start
 
    if (nHits_pat>=2) {
        abcal(result_pat, result_index, result_aw, result_bw, rpcLayerHits);
        if(msgLevel(MSG::DEBUG)){
            std::ostringstream ossR, ossZ;
            bool isFirst{true};
            for (int i=0; i<8; ++i){
                if(result_pat.test(i)){
                    if (isFirst){
                        ossR << rpcLayerHits.hits_in_layer_R.at(i).at(result_index[i]);
                        ossZ << rpcLayerHits.hits_in_layer_Z.at(i).at(result_index[i]);
                        isFirst=false;
                    }else{
                        ossR << "," << rpcLayerHits.hits_in_layer_R.at(i).at(result_index[i]);
                        ossZ << "," << rpcLayerHits.hits_in_layer_Z.at(i).at(result_index[i]);
                    }
                }
            }
            std::ostringstream oss;
            std::copy(result_index.begin(), result_index.end(), std::ostream_iterator<int>(oss, " "));
            ATH_MSG_DEBUG("patfinder: BEST pat= " << result_pat << " nHit: " << nHits_pat << " Idx: " << oss.str()
                <<"  dMM= "<<result_dMM <<"  dMO= "<<result_dMO << " R_hits: " << ossR.str() << " Z_hits: " << ossZ.str()
                <<" Slopes: " << result_aw[0] << "," << result_aw[1] << "," << result_aw[2] << " Offsets: " << result_bw[0] << "," << result_bw[1] << "," << result_bw[2]);
        }
        return true;
    }
    return false;
}

findPatternPhi()

bool TrigL2MuonSA::RpcPatFinder::findPatternPhi	(	double &	phi_middle,
		double &	phi_outer,
		const TrigL2MuonSA::RpcLayerHits &	rpcLayerHits ) const

Definition at line 165 of file RpcPatFinder.cxx.

                                                                                                   {
  const int N_layers=8;
 
  const std::vector<std::vector<double>>& rpc_phi {rpcLayerHits.hits_in_layer_phi};
  
  int l_start_max=2; //max layer of first hit
  if (rpc_phi.at(6).size()+rpc_phi.at(7).size()>0) l_start_max=5; // special "feet" towers
 
  // reset parameters
  phi_middle=0;
  phi_outer=0;
  double result_dMM{9999}, result_dMO{9999};
  int nHits_pat=0;
 
  // Loop on start layer
  for (int l_start=0; l_start<=l_start_max; l_start++){
    // Loop on hits of start layer, for each hit try a new pattern
    for (const double& phi_start : rpc_phi.at(l_start)){
        // Initialize a new pattern
        int nHits=1;
        double dMO{9999}; // lowest deltaX between two consecutive hits, when having at least one of the two hit in BO
        double dMM{9999}; // lowest deltaX between two consecutive hits, when having both hits in BM, or both in BO (but different doublets)
 
        int current_l = l_start;
        double current_phi = phi_start; // set current_x to the starting hit
 
        // ----- add compatible hits in other layers ----//
            // loop on test layers:
            for (int l_test=l_start+1; l_test<N_layers; l_test++){
                double min_delta {999};   // min deltaX in this test laeyr
                double layer_phi {0.};
 
                for (const double& phi_test : rpc_phi.at(l_test)){
                    double delta=-1;
                    // check if within the road
                    if (deltaOK(current_l,l_test,current_phi, phi_test,true,delta)){
                        // if closest hit we keep it as best hit for this test layer
                        if (delta < min_delta) {
                            min_delta = delta;
                            layer_phi = phi_test;
                        }
                    }
                }
                if (min_delta < 998){   //we found at least one hit in the window
                    current_l = l_test; 
                    current_phi = layer_phi;
                    nHits+=1;
                    dMO = (l_start<4 and l_test>=4) ? std::min(dMO, min_delta) : dMO;
                    dMM = (l_start<2 and l_test>=2 and l_test<4) or (l_start>=4 and l_start<5 and l_test>=6) ? std::min(dMM, min_delta) : dMM;
                }
            }
 
            // if longest pattern found and the last hit is in a layer > BM doublet1, update result
            if (nHits>nHits_pat and current_l > 1) { 
                nHits_pat=nHits;
                result_dMO=dMO; 
                result_dMM=dMM; 
                phi_middle=phi_start;
                phi_outer=current_phi;
            }else if (nHits==nHits_pat and current_l > 1) { 
                // if same lenght but smallest dMM/dMO, update result
                if (dMM<result_dMM or (dMM==result_dMM and dMO<result_dMO)){
                    result_dMO=dMO;
                    result_dMM=dMM;
                    phi_middle=phi_start;
                    phi_outer=current_phi;
                }
            }
        }//for i_start
    }//for l_start
    
    if (nHits_pat>2) {
        ATH_MSG_DEBUG("patfinder: BEST phi path dMM= "<<result_dMM <<"  dMO= "<<result_dMO 
                <<"  phi_middle= "<<phi_middle <<"  phi_outer= "<<phi_outer);
        return true;
    }
    return false;
}

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.

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 >, and AthCheckedComponent<::AthAlgTool >.

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_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:

• RpcPatFinder.h
• RpcPatFinder.cxx