#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: More...

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

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

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

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

bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

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

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

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 37 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 355 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, const int& l, const int& companion) -> void {
     
         if (result_pat.test(companion)){
             R = (rpc_R.at(l).at(index[l]) + rpc_R.at(companion).at(index[companion])) / 2.0;
             Z = (rpc_Z.at(l).at(index[l]) + rpc_Z.at(companion).at(index[companion])) / 2.0;
             return;
         }
         R = rpc_R.at(l).at(index[l]);
         Z = rpc_Z.at(l).at(index[l]);
     };
  
     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 22 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

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 326 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() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

◆ declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

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

95 { return m_detStore; }

◆ evtStore() [1/2]

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.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { 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 61 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 169 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() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ 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 DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

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

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Member Function Documentation

◆ abcal()

◆ addHit()

◆ AthAlgTool()

◆ calibR()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ deltaOK()

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ extraDeps_update_handler()

◆ findPatternEta()

◆ findPatternPhi()

◆ inputHandles()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_detStore

◆ m_evtStore

◆ m_varHandleArraysDeclared

◆ m_vhka