#include <TRT_SeededSpacePointFinder_ATL.h>

Inheritance diagram for InDet::TRT_SeededSpacePointFinder_ATL:

Collaboration diagram for InDet::TRT_SeededSpacePointFinder_ATL:

Classes
struct	bypass_struct

class	EventData

struct	invar_bypass_struct

Public Member Functions
	TRT_SeededSpacePointFinder_ATL (const std::string &, const std::string &, const IInterface *)
	Standard tool methods More...

virtual	~TRT_SeededSpacePointFinder_ATL ()

virtual StatusCode	initialize ()

virtual StatusCode	finalize ()

std::unique_ptr< InDet::ITRT_SeededSpacePointFinder::IEventData >	newEvent () const
	Method to initialize tool for new event More...

std::unique_ptr< InDet::ITRT_SeededSpacePointFinder::IEventData >	newRegion (const std::vector< IdentifierHash > &, const std::vector< IdentifierHash > &) const

std::list< std::pair< const Trk::SpacePoint , const Trk::SpacePoint > >	find2Sp (const EventContext &ctx, const Trk::TrackParameters &, ITRT_SeededSpacePointFinder::IEventData &event_data) const
	Main method of seed production More...

const SiSpacePointsSeed *	next (ITRT_SeededSpacePointFinder::IEventData &event_data) const
	Iterator through seed collection.Not used in this implementation. More...

MsgStream &	dump (MsgStream &out) const
	Print internal tool parameters and status More...

std::ostream &	dump (std::ostream &out) const

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 > &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

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Protected Member Functions
MsgStream &	dumpConditions (MsgStream &out) const
	Protected methods More...

MsgStream &	dumpEvent (MsgStream &out, InDet::TRT_SeededSpacePointFinder_ATL::EventData &event_data) const

void	fillLists (std::vector< std::vector< const Trk::SpacePoint * > > &r_Sorted, InDet::TRT_SeededSpacePointFinder_ATL::EventData &event_data) const
	Fill the space point container lists at beginning of each event. More...

void	production2Spb (const EventContext &ctx, const Trk::TrackParameters &, int, std::list< std::pair< const Trk::SpacePoint , const Trk::SpacePoint > > &outputListBuffer, InDet::TRT_SeededSpacePointFinder_ATL::EventData &event_data) const
	Form possible space point combinations within allowed radial and pseudorapidity ranges. More...

void	geoInfo (const Trk::SpacePoint *, int &, int &) const
	Obtain geo model info for a specific space point More...

void	magneticFieldInit ()
	Get magnetic field properties More...

bool	cutTPb (const invar_bypass_struct &invar_bypass, const std::vector< bypass_struct > &prod_bypass, long, long, double) const
	Cut on chi2 based on TRT segment qOverP, theta and phi track parameters. More...

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

Protected Attributes
StringProperty	m_fieldmode
	Protected data and methods More...

Trk::MagneticFieldProperties	m_fieldprop

const SCT_ID *	m_sctId = nullptr
	Magnetic field properties More...

DoubleProperty	m_ptmin {this, "pTmin", 500., "Minimum pT cut"}
	Seed selection criteria More...

DoubleProperty	m_xiC {this, "Xi2C", 100., "qOverP based chi2 cut"}
	Max R-z direction cut More...

DoubleProperty	m_xiTC {this, "Xi2TC", 100., "theta based chi2 cut"}

DoubleProperty	m_xiFC {this, "Xi2FC", 100., "phi based chi2 cut"}

BooleanProperty	m_search {this, "NeighborSearch", true, "Do full neighbor search"}

BooleanProperty	m_loadFull

BooleanProperty	m_doCosmics

SG::ReadHandleKey< SpacePointContainer >	m_spacepointsPixname {this,"SpacePointsPixelName","PixelSpacePoints","RHK to retrieve Pixel SpacePointContainer"}
	Space points containers More...

SG::ReadHandleKey< SpacePointContainer >	m_spacepointsSCTname {this,"SpacePointsSCTName","SCT_SpacePoints","RHK to retrieve SCT SpacePointContainer"}

SG::ReadHandleKey< SpacePointOverlapCollection >	m_spacepointsOverlapname {this,"SpacePointsOverlapName","OverlapSpacePoints","RHK to retrieve OverlapCollection"}

SG::ReadHandleKey< Trk::PRDtoTrackMap >	m_prdToTrackMap {this,"PRDtoTrackMap",""}

SG::ReadCondHandleKey< AtlasFieldCacheCondObj >	m_fieldCondObjInputKey

Static Protected Attributes
static constexpr double	m_r_rmin = 0.

static constexpr double	m_r_rmax = 600.
	Minimum SCT radius to be searched More...

static constexpr double	m_r_rstep = 10.
	Maximum STC radius to be searched More...

static constexpr double	m_r1max = 560.
	Step size for space point storage More...

static constexpr double	m_r12min = 400.
	Max radius of last SCT layer More...

static constexpr double	m_r2min = 340.
	Min radius of last SCT layer More...

static constexpr double	m_dzdrmin = -4.
	Min radius to search for SP pairs More...

static constexpr double	m_dzdrmax = 4.
	Min R-z direction cut More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

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

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

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &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

InDet::TRT_SeededSpacePointFinderATL is a tool which produces Si track seeds using pairs of space points in the last 3 layers of the SCT.

Author: Thoma.nosp@m.s.Ko.nosp@m.ffas@.nosp@m.cern.nosp@m..ch

Definition at line 66 of file TRT_SeededSpacePointFinder_ATL.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

◆ TRT_SeededSpacePointFinder_ATL()

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

Standard tool methods

Definition at line 43 of file TRT_SeededSpacePointFinder_ATL.cxx.

   : AthAlgTool(t,n,p)
 {
   declareInterface<ITRT_SeededSpacePointFinder>(this);
 }

◆ ~TRT_SeededSpacePointFinder_ATL()

InDet::TRT_SeededSpacePointFinder_ATL::~TRT_SeededSpacePointFinder_ATL ( )

virtualdefault

Member Function Documentation

◆ cutTPb()

bool InDet::TRT_SeededSpacePointFinder_ATL::cutTPb	(	const invar_bypass_struct &	invar_bypass,
		const std::vector< bypass_struct > &	prod_bypass,
		long	bSP1,
		long	bSP2,
		double	H
	)		const

protected

Cut on chi2 based on TRT segment qOverP, theta and phi track parameters.

Definition at line 891 of file TRT_SeededSpacePointFinder_ATL.cxx.

 {
  
   double inv_r2 = tmp_prod_bypass[bSP2].invR;
   double inv_r1 = tmp_prod_bypass[bSP1].invR; // == u1 in original cutTP
   double r1 = tmp_prod_bypass[bSP1].R;
  
   double inv_rr2 = inv_r2*inv_r2;
   double x2 = tmp_prod_bypass[bSP2].X;
   double y2 = tmp_prod_bypass[bSP2].Y;
   double a1 = tmp_prod_bypass[bSP1].a;
   double b1 = tmp_prod_bypass[bSP1].b;
  
   double u2 = (a1*x2 + b1*y2)*inv_rr2;
   double v2 = (a1*y2 - b1*x2)*inv_rr2;
  
   double A = v2/(u2 - inv_r1);
   double B = 2.0*(v2 - A*u2);
   double CC = B*B/(1.0 + A*A);
   double rcrc = CC*r1*r1;
   double z1 =  tmp_prod_bypass[bSP1].Z;
   double T = -z1/(r1*(1.0 + 0.04*rcrc));
  
   if(H==0.) return false;
  
   double invpSignature = B*H;
  
   double invP2 = CC/(0.03*0.03*H*H*(1.0 + T*T));
  
   if (invpSignature >= 0 && invP2*0.9*0.9*m_ptmin*m_ptmin > 1.0) {
     return false;
   }
  
   double invp_min = tmp_invar_bypass.invp_min;
   double invp_max = tmp_invar_bypass.invp_max;
  
   double invp_min2 = tmp_invar_bypass.invp_min2;
   double invp_max2 = tmp_invar_bypass.invp_max2;
  
   if (invp_min >= 0) {
     if (invpSignature < 0 || invP2 < invp_min2) {
       return false;
     }
   }
   else {
     if (invpSignature < 0 && invP2 > invp_min2) {
       return false;
     }
   }
   if (invp_max >= 0) {
     if (invpSignature >= 0 && invP2 > invp_max2) {
       return false;
     }
   }
   else {
     if (invpSignature >= 0 || invP2 < invp_max2) {
       return false;
     }
   }
  
   //Estimate the seed polar angle. Make a chi2 cut based on that suggested by the TRT segment
  
   double theta_rating = rotrating(1.0, T);
   double tmin = tmp_invar_bypass.min_theta;
   double tmax = tmp_invar_bypass.max_theta;
  
   if (tmin > tmax) {
 #ifndef ANGLE_DISCO_COMPAT
   // correct math but incompatible with old version
     if (theta_rating >= 0) {
       tmax += 4.0;
     }
     else {
       tmin -= 4.0;
     }
 #else
   // compatibility mode
     if (tmin + tmax <= 0) {
       // center in "+" (YES, "+") range; any negative theta_rating => false
       tmax = 2.0; // forcing range into all positive
     }
     else {
       // center in "-" (YES, "-") range; any positive theta_rating => false
       tmin = -2.0; // forcing range into all negative
     }
 #endif
   }
  
   if (theta_rating < tmin || theta_rating > tmax) {
     return false;
   }
  
   double phi_rating = rotrating(-(b1 + a1*A), -(a1 - b1*A));
   double pmin = tmp_invar_bypass.min_phi;
   double pmax = tmp_invar_bypass.max_phi;
  
   if (pmin > pmax) {
 #ifndef ANGLE_DISCO_COMPAT
     // correct math but incompatible with old version
     if (phi_rating >= 0) {
       pmax += 4.0;
     }
     else {
       pmin -= 4.0;
     }
 #else
     // compatibility mode
     if (pmin + pmax <= 0) {
       // center in "+" (YES, "+") range; any negative phi_rating => false
       pmax = 2.0; // forcing range into all positive
     }
     else {
       // center in "-" (YES, "-") range; any positive phi_rating => false
       pmin = -2.0; // forcing range into all negative
     }
 #endif
   }
  
   return phi_rating >= pmin && phi_rating <= pmax;
 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	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 > &	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 > &	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 > &	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 > & 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.

95 { return m_detStore; }

◆ dump() [1/2]

MsgStream & InDet::TRT_SeededSpacePointFinder_ATL::dump ( MsgStream & out ) const

virtual

Print internal tool parameters and status

Implements InDet::ITRT_SeededSpacePointFinder.

Definition at line 482 of file TRT_SeededSpacePointFinder_ATL.cxx.

 {
    return dumpConditions(out);
 }

◆ dump() [2/2]

std::ostream & InDet::TRT_SeededSpacePointFinder_ATL::dump ( std::ostream & out ) const

virtual

Implements InDet::ITRT_SeededSpacePointFinder.

Definition at line 487 of file TRT_SeededSpacePointFinder_ATL.cxx.

 {
   return out;
 }

◆ dumpConditions()

MsgStream & InDet::TRT_SeededSpacePointFinder_ATL::dumpConditions ( MsgStream & out ) const

protected

Protected methods

Definition at line 346 of file TRT_SeededSpacePointFinder_ATL.cxx.

 {
   int n = 42-m_fieldCondObjInputKey.key().size();
   std::string s1; for(int i=0; i<n; ++i) s1.append(" "); s1.append("|");
   n     = 42-m_spacepointsSCTname.key().size();
   std::string s3; for(int i=0; i<n; ++i) s3.append(" "); s3.append("|");
   n     = 42-m_spacepointsOverlapname.key().size();
   std::string s4; for(int i=0; i<n; ++i) s4.append(" "); s4.append("|");
  
   std::string fieldmode[9] ={"NoField"       ,"ConstantField","SolenoidalField",
                  "ToroidalField" ,"Grid3DField"  ,"RealisticField" ,
                  "UndefinedField","AthenaField"  , "?????"         };
  
   int mode = m_fieldprop.magneticFieldMode();
   if(mode<0 || mode>8 ) mode = 8;
  
   n     = 62-fieldmode[mode].size();
   std::string s5; for(int i=0; i<n; ++i) s5.append(" "); s5.append("|");
  
   out<<"|---------------------------------------------------------------------|"
      <<std::endl;
   out<<"| Key of magentic field condition Object | "<<m_fieldCondObjInputKey.key()<<s1
      <<std::endl;
   out<<"| SCT      space points   | "<<m_spacepointsSCTname.key()<<s3
      <<std::endl;
   out<<"| Overlap  space points   | "<<m_spacepointsOverlapname.key()<<s4
      <<std::endl;
   out<<"| Magnetic field mode     | "<<fieldmode[mode]<<s5
      <<std::endl;
   out<<"| pTmin  (mev)            | "
      <<std::setw(12)<<std::setprecision(5)<<m_ptmin
      <<"                              |"<<std::endl;
   out<<"| max radius SP           | "
      <<std::setw(12)<<std::setprecision(5)<<m_r_rmax
      <<"                              |"<<std::endl;
   out<<"| radius step             | "
      <<std::setw(12)<<std::setprecision(5)<<m_r_rstep
      <<"                              |"<<std::endl;
   out<<"| min radius second SP(3) | "
      <<std::setw(12)<<std::setprecision(5)<<m_r2min
      <<"                              |"<<std::endl;
   out<<"| min radius first SP(3)  | "
      <<std::setw(12)<<std::setprecision(5)<<m_r12min
      <<"                              |"<<std::endl;
   out<<"| max radius first  SP(3) | "
      <<std::setw(12)<<std::setprecision(4)<<m_r1max
      <<"                              |"<<std::endl;
   out<<"| min seeds dZ/dR         | "
      <<std::setw(12)<<std::setprecision(5)<<m_dzdrmin
      <<"                              |"<<std::endl;
   out<<"| max seeds dZ/dR         | "
      <<std::setw(12)<<std::setprecision(5)<<m_dzdrmax
      <<"                              |"<<std::endl;
   out<<"| momentum chi2 cut       | "
      <<std::setw(12)<<std::setprecision(5)<<m_xiC
      <<"                              |"<<std::endl;
   out<<"| polar angle chi2 cut    | "
      <<std::setw(12)<<std::setprecision(5)<<m_xiTC
      <<"                              |"<<std::endl;
   out<<"| azimuthal angle chi2 cut    | "
      <<std::setw(12)<<std::setprecision(5)<<m_xiFC
      <<"                              |"<<std::endl;
   out<<"|---------------------------------------------------------------------|"
      <<std::endl;
   return out;
 }

◆ dumpEvent()

MsgStream & InDet::TRT_SeededSpacePointFinder_ATL::dumpEvent	(	MsgStream &	out,
		InDet::TRT_SeededSpacePointFinder_ATL::EventData &	event_data
	)		const

protected

Definition at line 436 of file TRT_SeededSpacePointFinder_ATL.cxx.

 {
   const double pi2    = 2.*M_PI;
   out<<"|---------------------------------------------------------------------|"
      <<"\n";
   out<<"| m_ns                    | "
      <<std::setw(12)<<event_data.m_ns
      <<"                              |"<<"\n";
   out<<"|---------------------------------------------------------------------|"
      <<"\n";
  
   if(msgLvl(MSG::DEBUG)) return out;
  
   out<<"|-------------|--------|-------|-------|-------|-------|-------|";
   out<<"-------|-------|-------|-------|-------|-------|"
      <<"\n";
  
   out<<"|  Azimuthal  |    n   | z[ 0] | z[ 1] | z[ 2] | z[ 3] | z[4]  |";
   out<<" z[ 5] | z[ 6] | z[ 7] | z[ 8] | z[ 9] | z[10] |"
      <<"\n";
   out<<"|-------------|--------|-------|-------|-------|-------|-------|";
   out<<"-------|-------|-------|-------|-------|-------|"
      <<"\n";
  
   double sF1 = pi2/double(event_data.m_fNmax+1);
  
   //StreamState restore_precision(out);
   auto prec(out.precision());
   for(int f=0; f<=event_data.m_fNmax; ++f) {
     out<<"|  "
        <<std::setw(10)<<std::setprecision(4)<<sF1*double(f)<<" | "
        <<std::setw(6)<<event_data.m_rf_map[f]<<" |";
     out<<"\n";
   }
   out<<"|-------------|--------|-------|-------|-------|-------|-------|";
   out<<"-------|-------|-------|-------|-------|-------|"
      <<"\n";
   out<<endmsg;
   out.precision(prec);
   return out;
 }

◆ 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

◆ fillLists()

void InDet::TRT_SeededSpacePointFinder_ATL::fillLists	(	std::vector< std::vector< const Trk::SpacePoint * > > &	r_Sorted,
		InDet::TRT_SeededSpacePointFinder_ATL::EventData &	event_data
	)		const

protected

Fill the space point container lists at beginning of each event.

Definition at line 523 of file TRT_SeededSpacePointFinder_ATL.cxx.

 {
   assert( static_cast<size_t>(event_data.m_r_size) == r_Sorted.size());
   const double pi2 = 2.*M_PI;
  
   for(int i=0; i!= event_data.m_r_size;  ++i) {
     if(!event_data.m_r_map[i]) continue;
     for(const Trk::SpacePoint *space_point : r_Sorted[i]) {
  
       // Azimuthal angle sort
       //
       double F = space_point->phi(); if(F<0.) F+=pi2;
       int   f = int(F*event_data.m_sF);
       if (f < 0)
         f += event_data.m_fNmax;
       else if (f > event_data.m_fNmax)
         f -= event_data.m_fNmax;
       int isBRL = 1000; int isLYR = 1000; int DD = 1000;
  
       geoInfo(space_point,isBRL,isLYR);
  
       // Use 4 lower bits (Mask ==  ((2^4 -1) == 15)) for isLYR
       // the upper 28 bits for isBRL (including sign)
       DD = ((isBRL+3) << 4) + (isLYR & 15);
  
       event_data.m_rf_Sorted[f].emplace_back(space_point,DD);
       if(!event_data.m_rf_map[f]++) event_data.m_rf_index[event_data.m_nrf++] = f;
  
     }
     event_data.m_r_map[i] = 0;
   }
  
   event_data.m_nr    = 0;
 }

◆ finalize()

StatusCode InDet::TRT_SeededSpacePointFinder_ATL::finalize ( )

virtual

Implements InDet::ITRT_SeededSpacePointFinder.

Definition at line 92 of file TRT_SeededSpacePointFinder_ATL.cxx.

 {
    StatusCode sc = AthAlgTool::finalize(); return sc;
  
 }

◆ find2Sp()

std::list< std::pair< const Trk::SpacePoint , const Trk::SpacePoint > > InDet::TRT_SeededSpacePointFinder_ATL::find2Sp	(	const EventContext &	ctx,
		const Trk::TrackParameters &	tP,
		ITRT_SeededSpacePointFinder::IEventData &	event_data
	)		const

virtual

Main method of seed production

List of produced space point seeds

Get the phi segment index to use

Implements InDet::ITRT_SeededSpacePointFinder.

Definition at line 306 of file TRT_SeededSpacePointFinder_ATL.cxx.

 {
   InDet::TRT_SeededSpacePointFinder_ATL::EventData &event_data = EventData::getPrivateEventData(virt_event_data);
  
   const double pi2 = 2.*M_PI;
  
   std::list<std::pair<const Trk::SpacePoint*,const Trk::SpacePoint*> > outputListBuffer;
  
   double F = 0.;
   double GPx=tP.position().x(); double GPy=tP.position().y();
   F=atan2(GPy,GPx); if(F<0.) F+=pi2;
   int f = int(F*event_data.m_sF);
   if (f < 0)
     f += event_data.m_fNmax;
   else if (f > event_data.m_fNmax)
     f -= event_data.m_fNmax;
  
  
   production2Spb (ctx, tP,f, outputListBuffer,event_data); //Get a list of SP pairs.
  
   if(msgLvl(MSG::DEBUG)) {
      dumpEvent( msg(MSG::DEBUG), event_data);
      dumpConditions( msg(MSG::DEBUG));
      msg(MSG::DEBUG) << endmsg;
   }
  
   if(outputListBuffer.size()>10000.) outputListBuffer.clear();
  
   return outputListBuffer;
 }

◆ geoInfo()

void InDet::TRT_SeededSpacePointFinder_ATL::geoInfo	(	const Trk::SpacePoint *	SP,
		int &	isB,
		int &	ld
	)		const

protected

Obtain geo model info for a specific space point

Definition at line 1022 of file TRT_SeededSpacePointFinder_ATL.cxx.

 {
   const Trk::PrepRawData* p1;
   const InDet::SCT_Cluster* c1;
   Identifier id;
  
   p1 = SP->clusterList().first;
   if(p1){
     c1=dynamic_cast<const InDet::SCT_Cluster*>(p1);
     if(c1){
       id=c1->detectorElement()->identify();
       isB = m_sctId->barrel_ec(id);
       ld = m_sctId->layer_disk(id);
     }
   }
  
 }

◆ initialize()

StatusCode InDet::TRT_SeededSpacePointFinder_ATL::initialize ( )

virtual

Implements InDet::ITRT_SeededSpacePointFinder.

Definition at line 61 of file TRT_SeededSpacePointFinder_ATL.cxx.

 {
   magneticFieldInit();
  
   // PRD-to-track association (optional)
   ATH_CHECK( m_prdToTrackMap.initialize( !m_prdToTrackMap.key().empty()));
   ATH_CHECK( m_fieldCondObjInputKey.initialize());
   StatusCode sc = detStore()->retrieve(m_sctId, "SCT_ID");
   if (sc.isFailure()){
     msg(MSG::FATAL) << "Could not get SCT_ID helper !" << endmsg;
     return StatusCode::FAILURE;
   }
  
   // Build framework
   //
  
   // Get output print level
   //
   if(msgLvl(MSG::DEBUG)){ dumpConditions(msg(MSG::DEBUG)); msg(MSG::DEBUG)<<endmsg; }
  
   ATH_CHECK(m_spacepointsPixname.initialize());
   ATH_CHECK(m_spacepointsSCTname.initialize());
   ATH_CHECK(m_spacepointsOverlapname.initialize());
  
   return sc;
 }

◆ 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 & InDet::ITRT_SeededSpacePointFinder::interfaceID ( )

inlinestaticinherited

Definition at line 108 of file ITRT_SeededSpacePointFinder.h.

     {
       return IID_ITRT_SeededSpacePointFinder;
     }

◆ magneticFieldInit()

void InDet::TRT_SeededSpacePointFinder_ATL::magneticFieldInit ( )

protected

Get magnetic field properties

Definition at line 1044 of file TRT_SeededSpacePointFinder_ATL.cxx.

 {
  if(m_fieldmode == "NoField") m_fieldprop = Trk::MagneticFieldProperties(Trk::NoField);
  else if(m_fieldmode == "MapSolenoid") m_fieldprop = Trk::MagneticFieldProperties(Trk::FastField);
  else m_fieldprop = Trk::MagneticFieldProperties(Trk::FullField);
 }

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

◆ newEvent()

std::unique_ptr< InDet::ITRT_SeededSpacePointFinder::IEventData > InDet::TRT_SeededSpacePointFinder_ATL::newEvent ( ) const

virtual

Method to initialize tool for new event

Implements InDet::ITRT_SeededSpacePointFinder.

Definition at line 103 of file TRT_SeededSpacePointFinder_ATL.cxx.

 {
   std::unique_ptr<InDet::TRT_SeededSpacePointFinder_ATL::EventData> event_data_p = std::make_unique<InDet::TRT_SeededSpacePointFinder_ATL::EventData>();
   event_data_p->buildFrameWork(m_r_rmax, m_r_rstep, m_ptmin);
   // @TODO remove m_r_Sorted and directly fill m_rf_Sorted ?
  
   double irstep = 1./m_r_rstep;
  
   std::vector< std::vector<const Trk::SpacePoint*> > r_Sorted;
   r_Sorted.resize(event_data_p->m_r_size);
  
   if(m_loadFull){
     // Get pixel space points containers from store gate
     //
     SG::ReadHandle<SpacePointContainer> spacepointsPix(m_spacepointsPixname);
     if (spacepointsPix.isValid()) {
      SpacePointContainer::const_iterator spc =  spacepointsPix->begin  ();
       SpacePointContainer::const_iterator spce =  spacepointsPix->end  ();
  
       for(; spc != spce; ++spc) {
  
         SpacePointCollection::const_iterator sp  = (*spc)->begin();
         SpacePointCollection::const_iterator spe = (*spc)->end  ();
         for(; sp != spe; ++sp) {
  
       double r = (*sp)->r(); if(r<0. || r>=m_r_rmax) continue;
       int   ir = int(r*irstep);
       const Trk::SpacePoint* sps = (*sp);
           r_Sorted[ir].push_back(sps);
           ++event_data_p->m_r_map[ir];
       if(event_data_p->m_r_map[ir]==1) event_data_p->m_r_index[event_data_p->m_nr++] = ir;
       ++event_data_p->m_ns;
         }
       }
     }
   }
  
   SG::ReadHandle<Trk::PRDtoTrackMap>  prd_to_track_map;
   if (!m_prdToTrackMap.key().empty()) {
     prd_to_track_map=SG::ReadHandle<Trk::PRDtoTrackMap>(m_prdToTrackMap);
     if (!prd_to_track_map.isValid()) {
       ATH_MSG_ERROR("Failed to read PRD to track association map.");
     }
   }
   // Get sct space points containers from store gate
   //
   SG::ReadHandle<SpacePointContainer> spacepointsSCT(m_spacepointsSCTname);
   if (spacepointsSCT.isValid()) {
  
     SpacePointContainer::const_iterator spc  =  spacepointsSCT->begin();
     SpacePointContainer::const_iterator spce =  spacepointsSCT->end  ();
  
     double r_rmin = (!m_loadFull) ? m_r2min : m_r_rmin;
     for(; spc != spce; ++spc) {
  
       SpacePointCollection::const_iterator sp  = (*spc)->begin();
       SpacePointCollection::const_iterator spe = (*spc)->end  ();
       for(; sp != spe; ++sp) {
  
         if(prd_to_track_map.cptr()){
           bool u1=false; bool u2=false;
           const Trk::PrepRawData* p1=(*sp)->clusterList().first; u1=prd_to_track_map->isUsed(*p1);
           const Trk::PrepRawData* p2=(*sp)->clusterList().second;u2=prd_to_track_map->isUsed(*p2);
           if(u1 || u2){continue;}
         }
  
         double r = (*sp)->r(); if(r<r_rmin || r>=m_r_rmax) continue;
     int   ir = int(r*irstep);
     const Trk::SpacePoint* sps = (*sp);
         r_Sorted[ir].push_back(sps); ++event_data_p->m_r_map[ir];
     if(event_data_p->m_r_map[ir]==1) event_data_p->m_r_index[event_data_p->m_nr++] = ir;
     ++event_data_p->m_ns;
       }
     }
   }
  
   // Get sct overlap space points containers from store gate
   //
   SG::ReadHandle<SpacePointOverlapCollection> spacepointsOverlap(m_spacepointsOverlapname);
   if (spacepointsOverlap.isValid()) {
     SpacePointOverlapCollection::const_iterator sp  = spacepointsOverlap->begin();
     SpacePointOverlapCollection::const_iterator spe = spacepointsOverlap->end  ();
  
     for (; sp!=spe; ++sp) {
  
       if(prd_to_track_map.cptr()){
         bool u1=false; bool u2=false;
         const Trk::PrepRawData* p1=(*sp)->clusterList().first; u1=prd_to_track_map->isUsed(*p1);
         const Trk::PrepRawData* p2=(*sp)->clusterList().second;u2=prd_to_track_map->isUsed(*p2);
         if(u1 || u2){continue;}
       }
  
       double r = (*sp)->r(); if(r<0. || r>=m_r_rmax) continue;
       int   ir = int(r*irstep);
       const Trk::SpacePoint* sps = (*sp);
       r_Sorted[ir].push_back(sps); ++event_data_p->m_r_map[ir];
       if(event_data_p->m_r_map[ir]==1) event_data_p->m_r_index[event_data_p->m_nr++] = ir;
       ++event_data_p->m_ns;
     }
   }
  
   fillLists(r_Sorted, *event_data_p);  //Fill the R-phi sectors with the corresponding space points
   return std::unique_ptr<InDet::ITRT_SeededSpacePointFinder::IEventData>(event_data_p.release());
 }

◆ newRegion()

std::unique_ptr< InDet::ITRT_SeededSpacePointFinder::IEventData > InDet::TRT_SeededSpacePointFinder_ATL::newRegion	(	const std::vector< IdentifierHash > &	vPixel,
		const std::vector< IdentifierHash > &	vSCT
	)		const

virtual

Implements InDet::ITRT_SeededSpacePointFinder.

Definition at line 212 of file TRT_SeededSpacePointFinder_ATL.cxx.

 {
   std::unique_ptr<InDet::TRT_SeededSpacePointFinder_ATL::EventData> event_data_p = std::make_unique<InDet::TRT_SeededSpacePointFinder_ATL::EventData>();
   event_data_p->buildFrameWork(m_r_rmax, m_r_rstep, m_ptmin);
  
   std::vector< std::vector<const Trk::SpacePoint*> > r_Sorted;
   r_Sorted.resize(event_data_p->m_r_size);
  
   double irstep = 1./m_r_rstep;
  
   if(m_loadFull && !vPixel.empty()){
     // Get pixel space points containers from store gate
     //
     SG::ReadHandle<SpacePointContainer> spacepointsPix(m_spacepointsPixname);
     if (spacepointsPix.isValid()) {
       std::vector<IdentifierHash>::const_iterator l = vPixel.begin(), le = vPixel.end();
  
       // Loop through all trigger collections
       //
       for(; l!=le; ++l) {
  
     const SpacePointCollection  *w =  spacepointsPix->indexFindPtr(*l);
     if(w==nullptr) continue;
         SpacePointCollection::const_iterator sp  = w->begin();
         SpacePointCollection::const_iterator spe = w->end  ();
         for(; sp != spe; ++sp) {
  
       double r = (*sp)->r(); if(r<0. || r>=m_r_rmax) continue;
       int   ir = int(r*irstep);
       const Trk::SpacePoint* sps = (*sp);
           r_Sorted[ir].push_back(sps); ++event_data_p->m_r_map[ir];
       if(event_data_p->m_r_map[ir]==1) event_data_p->m_r_index[event_data_p->m_nr++] = ir;
       ++event_data_p->m_ns;
         }
       }
     }
   }
  
   // Get sct space points containers from store gate
   //
   if(!vSCT.empty()) {
  
     SG::ReadHandle<SpacePointContainer> spacepointsSCT(m_spacepointsSCTname);
     if (spacepointsSCT.isValid()) {
  
       SG::ReadHandle<Trk::PRDtoTrackMap>  prd_to_track_map;
       if (!m_prdToTrackMap.key().empty()) {
         prd_to_track_map=SG::ReadHandle<Trk::PRDtoTrackMap>(m_prdToTrackMap);
         if (!prd_to_track_map.isValid()) {
           ATH_MSG_ERROR("Failed to read PRD to track association map.");
         }
       }
       std::vector<IdentifierHash>::const_iterator l = vSCT.begin(), le = vSCT.end();
  
       // Loop through all trigger collections
       //
       double r_rmin = (!m_loadFull) ? m_r2min : m_r_rmin;
       for(; l!=le; ++l) {
  
     const SpacePointCollection  *w =  spacepointsSCT->indexFindPtr(*l);
     if(w==nullptr) continue;
         SpacePointCollection::const_iterator sp  = w->begin();
         SpacePointCollection::const_iterator spe = w->end  ();
         for(; sp != spe; ++sp) {
  
           if(prd_to_track_map.cptr()){
             bool u1=false; bool u2=false;
             const Trk::PrepRawData* p1=(*sp)->clusterList().first; u1=prd_to_track_map->isUsed(*p1);
             const Trk::PrepRawData* p2=(*sp)->clusterList().second;u2=prd_to_track_map->isUsed(*p2);
             if(u1 || u2){continue;}
           }
  
           double r = (*sp)->r(); if(r<r_rmin || r>=m_r_rmax) continue;
       int   ir = int(r*irstep);
       const Trk::SpacePoint* sps = (*sp);
           r_Sorted[ir].push_back(sps); ++event_data_p->m_r_map[ir];
       if(event_data_p->m_r_map[ir]==1) event_data_p->m_r_index[event_data_p->m_nr++] = ir;
       ++event_data_p->m_ns;
         }
       }
     }
   }
  
   fillLists(r_Sorted,*event_data_p);  //Fill the R-phi sectors with the corresponding space points
   return std::unique_ptr<InDet::ITRT_SeededSpacePointFinder::IEventData>(event_data_p.release());
 }

◆ next()

const SiSpacePointsSeed * InDet::TRT_SeededSpacePointFinder_ATL::next ( ITRT_SeededSpacePointFinder::IEventData & event_data ) const

inlinevirtual

Iterator through seed collection.Not used in this implementation.

Inline methods

Method to iterate through seeds.Not implemented

Implements InDet::ITRT_SeededSpacePointFinder.

Definition at line 267 of file TRT_SeededSpacePointFinder_ATL.h.

     {
       return 0;
     }

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

◆ production2Spb()

void InDet::TRT_SeededSpacePointFinder_ATL::production2Spb	(	const EventContext &	ctx,
		const Trk::TrackParameters &	tP,
		int	phi,
		std::list< std::pair< const Trk::SpacePoint , const Trk::SpacePoint > > &	outputListBuffer,
		InDet::TRT_SeededSpacePointFinder_ATL::EventData &	event_data
	)		const

protected

Form possible space point combinations within allowed radial and pseudorapidity ranges.

Get the momentum information from the track parameters

Set up the azimuthal width to look for SPs

Fill a list with the SP in the azimuthal region indicated by the TRT track segment

Definition at line 640 of file TRT_SeededSpacePointFinder_ATL.cxx.

 {
   uint64_t spcount = 0;
   // // // // // // <Fill the invar_bypass // // // // // // //
  
   //const Trk::MeasuredAtaStraightLine &ntP =
   //dynamic_cast<const Trk::MeasuredAtaStraightLine&>(tP);
   const AmgVector(5)& pTS=tP.parameters();
   const AmgSymMatrix(5)* vCM = tP.covariance();
  
   double sPhi = (*vCM)(2,2)  ; //Sigma on TRT segment azimuthal angle
   double sTheta = (*vCM)(3,3); //Sigma on TRT segment polar angle
   double sp = (*vCM)(4,4)    ; //Sigma on TRT segment inverse momentum estimate
  
   double ipdelta = sqrt(m_xiC*sp);
  
   invar_bypass_struct tmp_invar_bypass{};
   tmp_invar_bypass.invp_min = pTS[4] - ipdelta;
   tmp_invar_bypass.invp_max = pTS[4] + ipdelta;
  
   tmp_invar_bypass.invp_min2 = tmp_invar_bypass.invp_min*tmp_invar_bypass.invp_min;
   tmp_invar_bypass.invp_max2 = tmp_invar_bypass.invp_max*tmp_invar_bypass.invp_max;
  
   double theta_center = pTS[3];
   double theta_delta = sqrt(m_xiTC*sTheta);
  
   double phi_center = pTS[2];
   double phi_delta = sqrt(m_xiFC*sPhi);
  
   bracket_angle(theta_center, theta_delta,
         &(tmp_invar_bypass.min_theta), &(tmp_invar_bypass.max_theta));
   bracket_angle(phi_center, phi_delta,
         &(tmp_invar_bypass.min_phi), &(tmp_invar_bypass.max_phi));
  
   // // // // // // Fill the invar_bypass> // // // // // // //
  
   double x0=tP.position().x()  ;
   double y0=tP.position().y()  ;
   double z0=tP.position().z()  ;
   double H[3]; double gP[3] = {x0,y0,z0};
  
   // Get field cache object
   SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCondObjInputKey, ctx};
   const AtlasFieldCacheCondObj* fieldCondObj{*readHandle};
   if (fieldCondObj == nullptr) {
     ATH_MSG_ERROR("TRT_SeededSpacePointFinder_ATL: Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCondObjInputKey.key());
     return;
   }
   MagField::AtlasFieldCache    fieldCache;
   fieldCondObj->getInitializedCache (fieldCache);
   fieldCache.getField (gP, H);
  
   //need conversion kilotesla -> kilogauss - Previously used getMagneticFiledKiloGauss, whereas new function returns value in kiloTesla...
   H[0] *= 10000;
   H[1] *= 10000;
   H[2] *= 10000;
  
   std::list<std::pair<const Trk::SpacePoint*,int> >::iterator r0,r0e,r,re, rb;
   const Trk::SpacePoint* SpToPair = nullptr;
  
  
   //
   int fmin=phi; int fmax=phi;
   if(m_search){fmin = phi-1; fmax = phi+1;}
   for(int f=fmin; f<=fmax; ++f) {
     int j=0; f<0 ? j=f+event_data.m_fNmax+1 : f>event_data.m_fNmax ? j=f-event_data.m_fNmax-1 : j=f;
     if(!event_data.m_rf_map[j]){
       continue;
     }
     r0 = event_data.m_rf_Sorted[j].begin();
     r0e = event_data.m_rf_Sorted[j].end();
  
     for(; r0!=r0e; ++r0){
       if((((*r0).first)->r() > m_r1max) ||
      (((*r0).first)->r() < m_r2min)) {
     continue; //Fill only the SCT SPs
       }
       event_data.m_newRfi_Sorted.push_back(*r0);
     }
   }
  
   if(event_data.m_newRfi_Sorted.size()>5000 && event_data.m_newRfi_Sorted.size()<=10000) {
     event_data.m_newRfi_Sorted.erase(event_data.m_newRfi_Sorted.begin(),event_data.m_newRfi_Sorted.end());
     int fmin=phi; int fmax=phi;
     for(int f=fmin; f<=fmax; ++f) {
       int j=0; f<0 ? j=f+event_data.m_fNmax+1 : f>event_data.m_fNmax ? j=f-event_data.m_fNmax-1 : j=f;
       if(!event_data.m_rf_map[j]){
     continue;
       }
       r0 = event_data.m_rf_Sorted[j].begin();
       r0e = event_data.m_rf_Sorted[j].end();
  
       for(; r0!=r0e; ++r0){
     if((((*r0).first)->r()>m_r1max) || (((*r0).first)->r()<m_r2min)) {
       continue; //Fill only the SCT SPs
     }
     event_data.m_newRfi_Sorted.push_back(*r0);
       }
     }
   }
   if(event_data.m_newRfi_Sorted.size()>10000) {
     event_data.m_newRfi_Sorted.erase(event_data.m_newRfi_Sorted.begin(),event_data.m_newRfi_Sorted.end());
     return;
   }
  
   event_data.m_newRfi_Sorted.sort(MyNewDataSortPredicate());
  
   spcount = event_data.m_newRfi_Sorted.size();
  
   r  = event_data.m_newRfi_Sorted.begin();
   re = event_data.m_newRfi_Sorted.end();
  
   std::vector<bypass_struct> tmp_prod_bypass;
   std::vector<const Trk::SpacePoint *> vrp;
   std::vector<double> rk;
   std::vector<long> geo_info;
   std::vector<double> zSP;
   tmp_prod_bypass.reserve(spcount);
   vrp.reserve(spcount);
   rk.reserve(spcount);
   geo_info.reserve(spcount);
   zSP.reserve(spcount);
  
   // // // // // // <Fill m_prod_bypass and the local array // // // //
   for (; r != re; ++r) {
       const Trk::SpacePoint *vrpi = (*r).first;
  
       geo_info.push_back((*r).second);
       vrp.push_back(vrpi);
       rk.push_back(vrpi->r());
  
       double X = vrpi->globalPosition().x() - x0;
       double Y = vrpi->globalPosition().y() - y0;
       double zSPi = vrpi->globalPosition().z();
       zSP.push_back(zSPi);
       double Z = zSPi - z0;
  
       double RR = X*X + Y*Y;
       double R = sqrt(RR);
       double invR = 1.0/R;
  
       double a = X*invR;
       double b = Y*invR;
  
       tmp_prod_bypass.emplace_back();
       tmp_prod_bypass.back().X = X;
       tmp_prod_bypass.back().Y = Y;
       tmp_prod_bypass.back().Z = Z;
  
       tmp_prod_bypass.back().R = R;
       tmp_prod_bypass.back().invR = invR;
  
       tmp_prod_bypass.back().a = a;
       tmp_prod_bypass.back().b = b;
   }
  
   // // // // // // Fill m_prod_bypass and the local array> // // // //
  
  
   if (m_doCosmics) { // no need to check this every time in the loop
       for (long i = 0; i < (long)spcount; i++) {
           SpToPair = nullptr;
           const Trk::SpacePoint *up = vrp[i];
           for (long j = i + 1; j < (long)spcount; j++) {
               const Trk::SpacePoint *bp = vrp[j];
               SpToPair = bp;
               outputListBuffer.emplace_back(up, SpToPair);
           }
           if(!SpToPair) {
               outputListBuffer.emplace_back(up, up);
           }
       }
   }
   else { // (!m_doCosmics)
       for (long i = 0; i < (long)spcount; i++) {
           SpToPair = nullptr;
           const Trk::SpacePoint *up = vrp[i];
           double R = rk[i];
           if(R<m_r12min) {
               continue;
           }
           double Z = zSP[i];
           long geoi = geo_info[i];
           int isBU = (geoi >> 4)-3;
           int eleU = geoi & 15;
  
           for (long j = i + 1; j < (long)spcount; j++) {
               const Trk::SpacePoint *bp = vrp[j];
               double Zb = zSP[j];
               double Rb = rk[j];
               long geoj = geo_info[j];
               int isBB = (geoj >> 4)-3;
               int eleB = geoj & 15;
               // // // // // // // // // // // // // // // // // // // // // //
  
               // Equivalent to  {
               // if ((isBU == 0) && (isBB != isBU)) continue;
               // if((isBU == isBB) && (eleU <= eleB)) continue;
               // }
               // Rather cryptic but 2 to 3 times faster
               // than the 4 branches above...
  
               int Bd = (isBU - isBB) | (isBB - isBU);
               int Ed = (eleB - eleU);
               int BUzero = (isBU | -isBU);
               if (((BUzero | ~Bd) & (Bd | Ed) & (((unsigned)(-1) >> 1) + 1))
                   == 0) {
                   continue;
               }
  
               // // // // // // // // // // // // // // // // // // // // // //
               double dR = R - Rb;
               double dZ = Z - Zb;
               double dz_min = m_dzdrmin*dR;
               double dz_max = m_dzdrmax*dR;
               if (dZ < dz_min || dZ > dz_max) {
                   continue;//Should be within the +-2.5 pseudorapidity range
               }
               if(fieldCache.solenoidOn()) {
                   if(!cutTPb(tmp_invar_bypass, tmp_prod_bypass,i, j, H[2])) {
                       continue;
                   }
               }
               SpToPair = bp;
               outputListBuffer.emplace_back(up, SpToPair);
           }
           if(!SpToPair) {
               outputListBuffer.emplace_back(up, up);
           }
       }
   }
  
   event_data.m_newRfi_Sorted.erase(event_data.m_newRfi_Sorted.begin(),event_data.m_newRfi_Sorted.end());
 }

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

BooleanProperty InDet::TRT_SeededSpacePointFinder_ATL::m_doCosmics

protected

Initial value:

{this, "DoCosmics", false,

"Disable seed selection cuts during reconstruction of cosmics tracks"}

Definition at line 151 of file TRT_SeededSpacePointFinder_ATL.h.

◆ m_dzdrmax

constexpr double InDet::TRT_SeededSpacePointFinder_ATL::m_dzdrmax = 4.

staticconstexprprotected

Min R-z direction cut

Definition at line 143 of file TRT_SeededSpacePointFinder_ATL.h.

◆ m_dzdrmin

constexpr double InDet::TRT_SeededSpacePointFinder_ATL::m_dzdrmin = -4.

staticconstexprprotected

Min radius to search for SP pairs

Definition at line 142 of file TRT_SeededSpacePointFinder_ATL.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_fieldCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> InDet::TRT_SeededSpacePointFinder_ATL::m_fieldCondObjInputKey

protected

Initial value:

{this, "AtlasFieldCacheCondObj",

"fieldCondObj", "Name of the Magnetic Field conditions object key"}

Definition at line 206 of file TRT_SeededSpacePointFinder_ATL.h.

◆ m_fieldmode

StringProperty InDet::TRT_SeededSpacePointFinder_ATL::m_fieldmode

protected

Initial value:

{this, "MagneticFieldMode", "MapSolenoid",

"Magnetic field mode"}

Protected data and methods

Definition at line 121 of file TRT_SeededSpacePointFinder_ATL.h.

◆ m_fieldprop

Trk::MagneticFieldProperties InDet::TRT_SeededSpacePointFinder_ATL::m_fieldprop

protected

Definition at line 124 of file TRT_SeededSpacePointFinder_ATL.h.

◆ m_loadFull

BooleanProperty InDet::TRT_SeededSpacePointFinder_ATL::m_loadFull

protected

Initial value:

{this, "LoadFull", true,

"Load full Si space point container"}

Definition at line 149 of file TRT_SeededSpacePointFinder_ATL.h.

◆ m_prdToTrackMap

SG::ReadHandleKey<Trk::PRDtoTrackMap> InDet::TRT_SeededSpacePointFinder_ATL::m_prdToTrackMap {this,"PRDtoTrackMap",""}

protected

Definition at line 202 of file TRT_SeededSpacePointFinder_ATL.h.

◆ m_ptmin

DoubleProperty InDet::TRT_SeededSpacePointFinder_ATL::m_ptmin {this, "pTmin", 500., "Minimum pT cut"}

protected

Seed selection criteria

Definition at line 134 of file TRT_SeededSpacePointFinder_ATL.h.

◆ m_r12min

constexpr double InDet::TRT_SeededSpacePointFinder_ATL::m_r12min = 400.

staticconstexprprotected

Max radius of last SCT layer

Definition at line 140 of file TRT_SeededSpacePointFinder_ATL.h.

◆ m_r1max

constexpr double InDet::TRT_SeededSpacePointFinder_ATL::m_r1max = 560.

staticconstexprprotected

Step size for space point storage

Definition at line 139 of file TRT_SeededSpacePointFinder_ATL.h.

◆ m_r2min

constexpr double InDet::TRT_SeededSpacePointFinder_ATL::m_r2min = 340.

staticconstexprprotected

Min radius of last SCT layer

Definition at line 141 of file TRT_SeededSpacePointFinder_ATL.h.

◆ m_r_rmax

constexpr double InDet::TRT_SeededSpacePointFinder_ATL::m_r_rmax = 600.

staticconstexprprotected

Minimum SCT radius to be searched

Definition at line 137 of file TRT_SeededSpacePointFinder_ATL.h.

◆ m_r_rmin

constexpr double InDet::TRT_SeededSpacePointFinder_ATL::m_r_rmin = 0.

staticconstexprprotected

Definition at line 136 of file TRT_SeededSpacePointFinder_ATL.h.

◆ m_r_rstep

constexpr double InDet::TRT_SeededSpacePointFinder_ATL::m_r_rstep = 10.

staticconstexprprotected

Maximum STC radius to be searched

Definition at line 138 of file TRT_SeededSpacePointFinder_ATL.h.

◆ m_sctId

const SCT_ID* InDet::TRT_SeededSpacePointFinder_ATL::m_sctId = nullptr

protected

Magnetic field properties

ID SCT helper

Definition at line 128 of file TRT_SeededSpacePointFinder_ATL.h.

◆ m_search

BooleanProperty InDet::TRT_SeededSpacePointFinder_ATL::m_search {this, "NeighborSearch", true, "Do full neighbor search"}

protected

Definition at line 148 of file TRT_SeededSpacePointFinder_ATL.h.

◆ m_spacepointsOverlapname

SG::ReadHandleKey<SpacePointOverlapCollection> InDet::TRT_SeededSpacePointFinder_ATL::m_spacepointsOverlapname {this,"SpacePointsOverlapName","OverlapSpacePoints","RHK to retrieve OverlapCollection"}

protected

Definition at line 201 of file TRT_SeededSpacePointFinder_ATL.h.

◆ m_spacepointsPixname

SG::ReadHandleKey<SpacePointContainer> InDet::TRT_SeededSpacePointFinder_ATL::m_spacepointsPixname {this,"SpacePointsPixelName","PixelSpacePoints","RHK to retrieve Pixel SpacePointContainer"}

protected

Space points containers

Definition at line 199 of file TRT_SeededSpacePointFinder_ATL.h.

◆ m_spacepointsSCTname

SG::ReadHandleKey<SpacePointContainer> InDet::TRT_SeededSpacePointFinder_ATL::m_spacepointsSCTname {this,"SpacePointsSCTName","SCT_SpacePoints","RHK to retrieve SCT SpacePointContainer"}

protected

Definition at line 200 of file TRT_SeededSpacePointFinder_ATL.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.

◆ m_xiC

DoubleProperty InDet::TRT_SeededSpacePointFinder_ATL::m_xiC {this, "Xi2C", 100., "qOverP based chi2 cut"}

protected

Max R-z direction cut

Definition at line 145 of file TRT_SeededSpacePointFinder_ATL.h.

◆ m_xiFC

DoubleProperty InDet::TRT_SeededSpacePointFinder_ATL::m_xiFC {this, "Xi2FC", 100., "phi based chi2 cut"}

protected

Definition at line 147 of file TRT_SeededSpacePointFinder_ATL.h.

◆ m_xiTC

DoubleProperty InDet::TRT_SeededSpacePointFinder_ATL::m_xiTC {this, "Xi2TC", 100., "theta based chi2 cut"}

protected

Definition at line 146 of file TRT_SeededSpacePointFinder_ATL.h.

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

Classes

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ TRT_SeededSpacePointFinder_ATL()

◆ ~TRT_SeededSpacePointFinder_ATL()

Member Function Documentation

◆ cutTPb()

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

◆ detStore()

◆ dump() [1/2]

◆ dump() [2/2]

◆ dumpConditions()

◆ dumpEvent()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ extraDeps_update_handler()

◆ fillLists()

◆ finalize()

◆ find2Sp()

◆ geoInfo()

◆ initialize()

◆ inputHandles()

◆ interfaceID()

◆ magneticFieldInit()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ newEvent()

◆ newRegion()

◆ next()

◆ outputHandles()

◆ production2Spb()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_detStore

◆ m_doCosmics

◆ m_dzdrmax

◆ m_dzdrmin

◆ m_evtStore

◆ m_fieldCondObjInputKey

◆ m_fieldmode

◆ m_fieldprop

◆ m_loadFull

◆ m_prdToTrackMap

◆ m_ptmin

◆ m_r12min

◆ m_r1max

◆ m_r2min

◆ m_r_rmax

◆ m_r_rmin

◆ m_r_rstep

◆ m_sctId

◆ m_search

◆ m_spacepointsOverlapname

◆ m_spacepointsPixname

◆ m_spacepointsSCTname

◆ m_varHandleArraysDeclared