InDet::TRT_SeededSpacePointFinder_ATL Class Reference

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

#include <TRT_SeededSpacePointFinder_ATL.h>

Inheritance diagram for InDet::TRT_SeededSpacePointFinder_ATL:

Collaboration diagram for InDet::TRT_SeededSpacePointFinder_ATL:

Classes
class	EventData
struct	bypass_struct
struct	invar_bypass_struct

Public Member Functions
	TRT_SeededSpacePointFinder_ATL (const std::string &, const std::string &, const IInterface *)
	Standard tool methods.
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.
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.
const SiSpacePointsSeed *	next (ITRT_SeededSpacePointFinder::IEventData &event_data) const
	Iterator through seed collection.Not used in this implementation.
MsgStream &	dump (MsgStream &out) const
	Print internal tool parameters and status.
std::ostream &	dump (std::ostream &out) const
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Protected Member Functions
MsgStream &	dumpConditions (MsgStream &out) const
	Protected methods.
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.
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.
void	geoInfo (const Trk::SpacePoint *, int &, int &) const
	Obtain geo model info for a specific space point.
void	magneticFieldInit ()
	Get magnetic field properties.
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.
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Protected Attributes
StringProperty	m_fieldmode
	Protected data and methods.
Trk::MagneticFieldProperties	m_fieldprop
const SCT_ID *	m_sctId = nullptr
	Magnetic field properties.
DoubleProperty	m_ptmin {this, "pTmin", 500., "Minimum pT cut"}
	Seed selection criteria.
DoubleProperty	m_xiC {this, "Xi2C", 100., "qOverP based chi2 cut"}
	Max R-z direction cut.
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.
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.
static constexpr double	m_r_rstep = 10.
	Maximum STC radius to be searched.
static constexpr double	m_r1max = 560.
	Step size for space point storage.
static constexpr double	m_r12min = 400.
	Max radius of last SCT layer.
static constexpr double	m_r2min = 340.
	Min radius of last SCT layer.
static constexpr double	m_dzdrmin = -4.
	Min radius to search for SP pairs.
static constexpr double	m_dzdrmax = 4.
	Min R-z direction cut.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

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

Private Attributes
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

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 892 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()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

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 483 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 488 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;
  //coverity[STREAM_FORMAT_STATE:FALSE]
  out.precision(prec);
  return out;
}

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

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

protectedinherited

Add StoreName to extra input/output deps as needed.

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

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 524 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 1023 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 1045 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()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

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

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

Definition at line 641 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 asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, and AthCheckedComponent<::AthAlgTool >.

sysStart()

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

overridevirtualinherited

Handle START transition.

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

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

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

                                 {this, "DoCosmics", false,
    "Disable seed selection cuts during reconstruction of cosmics tracks"};

m_dzdrmax

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

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.

                                                                         {this, "AtlasFieldCacheCondObj",
        "fieldCondObj", "Name of the Magnetic Field conditions object key"};

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.

                                {this, "MagneticFieldMode", "MapSolenoid",
      "Magnetic field mode"};

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.

                                {this, "LoadFull", true,
    "Load full Si space point container"};

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.

{this,"PRDtoTrackMap",""};

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.

{this, "pTmin", 500., "Minimum pT cut"};

m_r12min

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

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

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

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

double InDet::TRT_SeededSpacePointFinder_ATL::m_r_rmin = 0.

staticconstexprprotected

Definition at line 136 of file TRT_SeededSpacePointFinder_ATL.h.

m_r_rstep

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.

{this, "NeighborSearch", true, "Do full neighbor search"};

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.

{this,"SpacePointsOverlapName","OverlapSpacePoints","RHK to retrieve OverlapCollection"}        ;

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.

{this,"SpacePointsPixelName","PixelSpacePoints","RHK to retrieve Pixel SpacePointContainer"}            ;

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.

{this,"SpacePointsSCTName","SCT_SpacePoints","RHK to retrieve SCT SpacePointContainer"}           ;

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.

{this, "Xi2C", 100., "qOverP based chi2 cut"};

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.

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

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.

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

---

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

• TRT_SeededSpacePointFinder_ATL.h
• TRT_SeededSpacePointFinder_ATL.cxx