InDet::TRT_DetElementsRoadMaker_xk Class Reference

InDet::TRT_DetElementsRoadMaker_xk is algorithm which produce list of InDetDD::TRT_BaseElement* sorted in propagation order. More...

#include <TRT_DetElementsRoadMaker_xk.h>

Inheritance diagram for InDet::TRT_DetElementsRoadMaker_xk:

Collaboration diagram for InDet::TRT_DetElementsRoadMaker_xk:

Public Member Functions
	TRT_DetElementsRoadMaker_xk (const std::string &, const std::string &, const IInterface *)
virtual	~TRT_DetElementsRoadMaker_xk ()
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual std::vector< const InDetDD::TRT_BaseElement * >	detElementsRoad (const EventContext &ctx, MagField::AtlasFieldCache &fieldCache, const Trk::TrackParameters &Tp, Trk::PropDirection D, InDet::TRT_DetElementLink_xk::TRT_DetElemUsedMap &used) const override
virtual MsgStream &	dump (MsgStream &out) const override
virtual std::ostream &	dump (std::ostream &out) const override
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
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	detElementsRoadATL (std::deque< Amg::Vector3D > &, std::vector< const InDetDD::TRT_BaseElement * > &, InDet::TRT_DetElementLink_xk::TRT_DetElemUsedMap &used, const EventContext &ctx) const
void	detElementsRoadCTB (std::deque< Amg::Vector3D > &, std::vector< const InDetDD::TRT_BaseElement * > &, InDet::TRT_DetElementLink_xk::TRT_DetElemUsedMap &used, const EventContext &ctx) const
Trk::CylinderBounds	getBound (MagField::AtlasFieldCache &fieldCache, const Trk::TrackParameters &, const EventContext &ctx) const
MsgStream &	dumpConditions (MsgStream &out) const
const TRT_DetElementsLayerVectors_xk *	getLayers (const EventContext &ctx) const
const Trk::CylinderBounds	get_bounds (const EventContext &ctx) const
double	getTRTMinR (const EventContext &ctx) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
static double	stepToDetElement (const InDetDD::TRT_BaseElement *&, Amg::Vector3D &, Amg::Vector3D &)
static MsgStream &	dumpEvent (MsgStream &out, int size_road)

Private Attributes
SG::ReadCondHandleKey< TRT_DetElementsRoadData_xk >	m_roadDataKey
SG::ReadCondHandleKey< AtlasFieldCacheCondObj >	m_fieldCacheCondObjInputKey
PublicToolHandle< Trk::IPropagator >	m_proptool
FloatProperty	m_width
DoubleProperty	m_step {this, "MaxStep", 20., "Max step allowed"}
StringProperty	m_fieldmode
Trk::MagneticFieldMode	m_fieldModeEnum {Trk::FullField}
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_DetElementsRoadMaker_xk is algorithm which produce list of InDetDD::TRT_BaseElement* sorted in propagation order.

Author

Igor..nosp@m.Gavr.nosp@m.ilenk.nosp@m.o@ce.nosp@m.rn.ch

Definition at line 61 of file TRT_DetElementsRoadMaker_xk.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_DetElementsRoadMaker_xk()

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

Definition at line 41 of file TRT_DetElementsRoadMaker_xk.cxx.

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

~TRT_DetElementsRoadMaker_xk()

InDet::TRT_DetElementsRoadMaker_xk::~TRT_DetElementsRoadMaker_xk ( )

virtualdefault

Member Function Documentation

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detElementsRoad()

std::vector< const InDetDD::TRT_BaseElement * > InDet::TRT_DetElementsRoadMaker_xk::detElementsRoad ( const EventContext & ctx, MagField::AtlasFieldCache & fieldCache, const Trk::TrackParameters & Tp, Trk::PropDirection D, InDet::TRT_DetElementLink_xk::TRT_DetElemUsedMap & used ) const

overridevirtual

Implements InDet::ITRT_DetElementsRoadMaker.

Definition at line 269 of file TRT_DetElementsRoadMaker_xk.cxx.

{
  double qp   = std::abs(500.*Tp.parameters()[4]) ; 
  if( qp < 1.e-10  ) qp = 1.e-10;
  double S    = m_step/qp                     ; 
  if( S  > 200.    ) S  = 200.  ; 
  if(D<0) S=-S;
  Trk::CylinderBounds CB = getBound(fieldCache, Tp, ctx);
  double rminTRT = getTRTMinR(ctx);
  std::vector<const InDetDD::TRT_BaseElement*> result;
  if( CB.r() > rminTRT) {
    Trk::MagneticFieldMode fieldModeEnum(m_fieldModeEnum);
    if(!fieldCache.solenoidOn()) fieldModeEnum = Trk::NoField;
    Trk::MagneticFieldProperties fieldprop(fieldModeEnum);
    std::deque<Amg::Vector3D> G;
    m_proptool->globalPositions(ctx, G,Tp,fieldprop,CB,S,Trk::pion);
    if(G.size() > 1 ) {
      detElementsRoadATL(G,result,used,ctx);
    }
  }
  return result;
}

detElementsRoadATL()

void InDet::TRT_DetElementsRoadMaker_xk::detElementsRoadATL ( std::deque< Amg::Vector3D > & GP, std::vector< const InDetDD::TRT_BaseElement * > & Road, InDet::TRT_DetElementLink_xk::TRT_DetElemUsedMap & used, const EventContext & ctx ) const

private

Definition at line 302 of file TRT_DetElementsRoadMaker_xk.cxx.

{
  int n0     = 0;
  int n1     = 0;
  int n2     = 0;
  std::deque<Amg::Vector3D>::iterator g=GP.begin(),ge=GP.end();
 
  const TRT_DetElementsLayerVectors_xk &layer = *getLayers(ctx);
 
  float Po[6] = {float((*g).x()),float((*g).y()),float((*g).z()),
         float(std::sqrt((*g).x()*(*g).x()+(*g).y()*(*g).y())),m_width,0.};
 
  for(; n0!=(int)layer[0].size(); ++n0) {if(Po[2] > layer[0][n0].z()) break;}
  for(; n1!=(int)layer[1].size(); ++n1) {if(Po[3] < layer[1][n1].r()) break;}
  for(; n2!=(int)layer[2].size(); ++n2) {if(Po[2] < layer[2][n2].z()) break;}
 
  std::vector<std::pair<const InDet::TRT_DetElementLink_xk*,float> > lDE;
  for (unsigned int module_i = 0; module_i < 3; ++module_i) {
    size_t layersSize = layer[module_i].size();
    //Add more vectors if we need more
    used[module_i].resize(layersSize);
    for (unsigned int layer_i = 0; layer_i < layersSize; ++layer_i) {
      // Although we clear/resize , we retain capacity
      // clear what was there before
      used[module_i][layer_i].clear();
      //default init to false 
      used[module_i][layer_i].resize(layer[module_i][layer_i].nElements());
    }
  }
 
  for(++g; g!=ge; ++g) {
 
    float Pn[4] = {float((*g).x()),float((*g).y()),float((*g).z()),
           float(std::sqrt((*g).x()*(*g).x()+(*g).y()*(*g).y()))};
 
    float dx = Pn[0]-Po[0];
    float dy = Pn[1]-Po[1];
    float dz = Pn[2]-Po[2];
    float st = std::sqrt(dx*dx+dy*dy+dz*dz); 
    if(st <=0.) continue;
    float ds = 1./st;
    float A[3]= {dx*ds,dy*ds,dz*ds};
 
    // Barrel
    //
    if (Pn[3] > Po[3]) {
        for (; n1 < (int)layer[1].size(); ++n1) {
 
          if (Pn[3] < layer[1][n1].r())
            break;
          assert(used.at(1).size() > static_cast<unsigned int>(n1));
          layer[1][n1].getBarrelDetElementsATL(Po, A, lDE, used[1][n1]);
        }
    } else {
        for (--n1; n1 >= 0; --n1) {
          if (Pn[3] > layer[1][n1].r())
            break;
          assert(used.at(1).size() > static_cast<unsigned int>(n1));
          layer[1][n1].getBarrelDetElementsATL(Po, A, lDE, used[1][n1]);
        }
        ++n1;
    }
 
    // Positive endcap
    //
    if(Pn[2]>Po[2]) {
 
      for (; n2 < (int)layer[2].size(); ++n2) {
        if (Pn[2] < layer[2][n2].z())
          break;
        assert(used.at(2).size() > static_cast<unsigned int>(n2));
        layer[2][n2].getEndcapDetElements(Po, A, lDE, used[2][n2]);
      }
    } else {
      for (--n2; n2 >= 0; --n2) {
        if (Pn[2] > layer[2][n2].z())
          break;
        assert(used.at(2).size() > static_cast<unsigned int>(n2));
        layer[2][n2].getEndcapDetElements(Po, A, lDE, used[2][n2]);
      }
      ++n2;
    }
 
    // Negative endcap
    //
    if(Pn[2]<Po[2]) {
 
      for (; n0 < (int)layer[0].size(); ++n0) {
        if (Pn[2] > layer[0][n0].z())
          break;
        assert(used.at(0).size() > static_cast<unsigned int>(n0));
        layer[0][n0].getEndcapDetElements(Po, A, lDE, used[0][n0]);
      }
    } else {
      for (--n0; n0 >= 0; --n0) {
        if (Pn[2] < layer[0][n0].z())
          break;
        assert(used.at(0).size() > static_cast<unsigned int>(n0));
        layer[0][n0].getEndcapDetElements(Po, A, lDE, used[0][n0]);
      }
      ++n0;
    }
    Po[0] = Pn[0];
    Po[1] = Pn[1];
    Po[2] = Pn[2];
    Po[3] = Pn[3];
    Po[5]+= st;
  }
 
  // Sort list in propogation order
  //
  std::vector<std::pair<const InDet::TRT_DetElementLink_xk*,float> >::iterator l=lDE.begin(),le=lDE.end(),n,m;
  if(l==le) return;
 
  bool nc =true;
  while(nc) {
 
    nc =false; m=l; n=l;
    for(++n; n!=le; ++n) {
 
      if( (*m).second > (*n).second ) {
         std::pair<const InDet::TRT_DetElementLink_xk*,float>  d=(*m); (*m)=(*n); (*n)=d; nc=true;
      }
      ++m;
    }
  }
 
  // Fill list pointers to detector elements
  //
  for(l=lDE.begin(); l!=le; ++l) {
    Road.push_back((*l).first->detElement());
  }
}

detElementsRoadCTB()

void InDet::TRT_DetElementsRoadMaker_xk::detElementsRoadCTB ( std::deque< Amg::Vector3D > & GP, std::vector< const InDetDD::TRT_BaseElement * > & Road, InDet::TRT_DetElementLink_xk::TRT_DetElemUsedMap & used, const EventContext & ctx ) const

private

Definition at line 445 of file TRT_DetElementsRoadMaker_xk.cxx.

{
  int n1     = 0;
  std::deque<Amg::Vector3D>::iterator g=GP.begin(),ge=GP.end();
 
  const TRT_DetElementsLayerVectors_xk &layer = *getLayers(ctx);
 
  float Po[6] = {float((*g).x()),float((*g).y()),float((*g).z()),
         float(std::sqrt((*g).x()*(*g).x()+(*g).y()*(*g).y())),m_width,0.};
 
  for(; n1!=(int)layer[1].size(); ++n1) {if(Po[3] < layer[1][n1].r()) break;}
 
  std::vector<std::pair<const InDet::TRT_DetElementLink_xk*,float> > lDE;
  for (unsigned int module_i = 0; module_i < 3; ++module_i) {
    size_t layersSize = layer[module_i].size();
    //Add more vectors if we need more
    used[module_i].resize(layersSize);
    for (unsigned int layer_i = 0; layer_i < layersSize; ++layer_i) {
      // Although we clear/resize , we retain capacity
      // clear what was there before
      used[module_i][layer_i].clear();
      //default init to false 
      used[module_i][layer_i].resize(layer[module_i][layer_i].nElements());
    }
  }
 
  for(++g; g!=ge; ++g) {
 
    float Pn[4] = {float((*g).x()),float((*g).y()),float((*g).z()),
           float(std::sqrt((*g).x()*(*g).x()+(*g).y()*(*g).y()))};
 
    float dx = Pn[0]-Po[0];
    float dy = Pn[1]-Po[1];
    float dz = Pn[2]-Po[2];
    float st = std::sqrt(dx*dx+dy*dy+dz*dz);
    float ds = 1./st;
    float A[3]= {dx*ds,dy*ds,dz*ds};
 
    // Barrel
    //
    if(Pn[3]>Po[3]) {
      for(; n1<(int)layer[1].size(); ++n1) {
    if(Pn[3] < layer[1][n1].r()) break;
        assert( used.at(1).size() > static_cast<unsigned int>(n1) );
    layer[1][n1].getBarrelDetElementsCTB(Po,A,lDE,used[1][n1]);
      }
    }
    else     {
      for(--n1; n1>=0; --n1) {
    if(Pn[3] > layer[1][n1].r()) break;
    layer[1][n1].getBarrelDetElementsCTB(Po,A,lDE,used[1][n1]);
      }
      ++n1;
    }
  }
 
  // Sort list in propogation order
  //
  std::vector<std::pair<const InDet::TRT_DetElementLink_xk*, float> >::iterator l=lDE.begin(),le=lDE.end(),n;
  if(l==le) return;
 
  bool nc =true;
  while(nc) {
 
    nc =false; n=l;
    for(++n; n!=le; ++n) {
 
      if( (*l).second > (*n).second ) {
         std::pair<const InDet::TRT_DetElementLink_xk*,float> d = (*l); (*l) = (*n); (*n) = d;
         nc = true;
      }
      ++l;
    }
  }
 
  // Fill list pointers to detector elements
  //
  for(l=lDE.begin(); l!=le; ++l) {
    Road.push_back((*l).first->detElement());
  }
}

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_DetElementsRoadMaker_xk::dump ( MsgStream & out ) const

overridevirtual

Implements InDet::ITRT_DetElementsRoadMaker.

Definition at line 87 of file TRT_DetElementsRoadMaker_xk.cxx.

{
  return dumpConditions(out);
}

dump() [2/2]

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

overridevirtual

Implements InDet::ITRT_DetElementsRoadMaker.

Definition at line 259 of file TRT_DetElementsRoadMaker_xk.cxx.

{
  return out;
}

dumpConditions()

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

private

Definition at line 96 of file TRT_DetElementsRoadMaker_xk.cxx.

{
  int n = 62-m_proptool.type().size();
  std::string s1; for(int i=0; i<n; ++i) s1.append(" "); s1.append("|");
 
  std::string fieldmode[9] ={"NoField"       ,"ConstantField","SolenoidalField",
                 "ToroidalField" ,"Grid3DField"  ,"RealisticField" ,
                 "UndefinedField","AthenaField"  , "?????"         };
 
  Trk::MagneticFieldMode fieldModeEnum(m_fieldModeEnum);
  SG::ReadCondHandle<AtlasFieldCacheCondObj> fieldHandle(m_fieldCacheCondObjInputKey);
  const AtlasFieldCacheCondObj* fieldCondObj{*fieldHandle};
  if (fieldCondObj) {
    MagField::AtlasFieldCache fieldCache;
    fieldCondObj->getInitializedCache (fieldCache);
    if(!fieldCache.solenoidOn()) fieldModeEnum = Trk::NoField;
  }
  Trk::MagneticFieldProperties fieldprop(fieldModeEnum);
  int mode = fieldprop.magneticFieldMode();
  if(mode<0 || mode>8 ) mode = 8;
 
  n     = 62-fieldmode[mode].size();
  std::string s3; for(int i=0; i<n; ++i) s3.append(" "); s3.append("|");
 
  const TRT_DetElementsLayerVectors_xk &layer = *getLayers(Gaudi::Hive::currentContext());
 
  int maps = 0;
  if(!layer[0].empty()) ++maps;
  if(!layer[1].empty()) ++maps;
  if(!layer[2].empty()) ++maps;
 
  out<<"|----------------------------------------------------------------------"
     <<"-------------------|"
     <<std::endl;
  out<<"| Tool for propagation    | "<<m_proptool.type()<<s1<<std::endl;
  out<<"| Magnetic field mode     | "<<fieldmode[mode]<<s3<<std::endl;
  out<<"| Width of the road (mm)  | "
     <<std::setw(12)<<std::setprecision(5)<<m_width
     <<"                                                  |"<<std::endl;
  out<<"|----------------------------------------------------------------------"
     <<"-------------------|"
     <<std::endl;
 
  if(!maps || !msgLvl(MSG::VERBOSE)) return out;
 
  if(!layer[1].empty()) {
    int nl = layer[1].size();
    int nc = 0;
    for(const auto & i : layer[1]) nc+=i.nElements();
    out<<"|----------------------------------------------------------------|"
       <<std::endl;
    out<<"| Barrel map containt "
       <<std::setw(4)<<nl<<" layers and "
       <<std::setw(6)<<nc<<" elements            |"
       <<std::endl;
    out<<"|------|-----------|------------|------------|------------|------|"
       <<std::endl;
    out<<"|   n  |     R     |   Z min    |   Z max    |  max dF    | nEl  |"
       <<std::endl;
    out<<"|------|-----------|------------|------------|------------|------|"
       <<std::endl;
    for(unsigned int i=0; i!=layer[1].size(); ++i) {
      float zmin = layer[1][i].z()-layer[1][i].dz();
      float zmax = layer[1][i].z()+layer[1][i].dz();
      out<<"| "
     <<std::setw(4)<<i<<" |"
     <<std::setw(10)<<std::setprecision(4)<<  layer[1][i].r ()<<" | "
     <<std::setw(10)<<std::setprecision(4)<<                zmin<<" | "
     <<std::setw(10)<<std::setprecision(4)<<                zmax<<" | "
     <<std::setw(10)<<std::setprecision(4)<< layer[1][i].dfe()<<" | "
     <<std::setw(4)<<layer[1][i].nElements()<<" | "
     <<std::endl;
    }
    out<<"|------|-----------|------------|------------|------------|------|"
       <<std::endl;
 
  }
  if(!layer[0].empty()) {
 
    int nl = layer[0].size();
    int nc = 0;
    for(const auto & i : layer[0]) nc+=i.nElements();
    out<<"|----------------------------------------------------------------|"
       <<std::endl;
    out<<"| L.Endcap map containt "
       <<std::setw(4)<<nl<<" layers and "
       <<std::setw(6)<<nc<<" elements          |"
       <<std::endl;
 
    out<<"|------|-----------|------------|------------|------------|------|"
       <<std::endl;
    out<<"|   n  |     Z     |   R min    |   R max    |  max dF    | nEl  |"
       <<std::endl;
    out<<"|------|-----------|------------|------------|------------|------|"
       <<std::endl;
    for(unsigned int i=0; i!=layer[0].size(); ++i) {
      float rmin = layer[0][i].r()-layer[0][i].dr();
      float rmax = layer[0][i].r()+layer[0][i].dr();
      out<<"| "
     <<std::setw(4)<<i<<" |"
     <<std::setw(10)<<std::setprecision(4)<<  layer[0][i].z()<<" | "
     <<std::setw(10)<<std::setprecision(4)<<               rmin<<" | "
     <<std::setw(10)<<std::setprecision(4)<<               rmax<<" | "
     <<std::setw(10)<<std::setprecision(4)<<layer[0][i].dfe()<<" | "
     <<std::setw(4)<<layer[0][i].nElements()<<" | "
     <<std::endl;
    }
    out<<"|------|-----------|------------|------------|------------|------|"
       <<std::endl;
  }
  if(!layer[2].empty()) {
    int nl = layer[2].size();
    int nc = 0;
    for(const auto & i : layer[2]) nc+=i.nElements();
    out<<"|----------------------------------------------------------------|"
       <<std::endl;
   out<<"| R.Endcap map containt "
       <<std::setw(4)<<nl<<" layers and "
       <<std::setw(6)<<nc<<" elements          |"
       <<std::endl;
    out<<"|------|-----------|------------|------------|------------|------|"
       <<std::endl;
    out<<"|   n  |     Z     |   R min    |   R max    |  max dF    | nEl  |"
       <<std::endl;
    out<<"|------|-----------|------------|------------|------------|------|"
       <<std::endl;
    for(unsigned int i=0; i!=layer[2].size(); ++i) {
      float rmin = layer[2][i].r()-layer[0][i].dr();
      float rmax = layer[2][i].r()+layer[0][i].dr();
      out<<"| "
     <<std::setw(4)<<i<<" |"
     <<std::setw(10)<<std::setprecision(4)<<  layer[2][i].z()<<" | "
     <<std::setw(10)<<std::setprecision(4)<<               rmin<<" | "
     <<std::setw(10)<<std::setprecision(4)<<               rmax<<" | "
     <<std::setw(10)<<std::setprecision(4)<<layer[2][i].dfe()<<" | "
     <<std::setw(4)<<layer[2][i].nElements()<<" | "
     <<std::endl;
    }
    out<<"|------|-----------|------------|------------|------------|------|"
       <<std::endl;
 }
  return out;
}

dumpEvent()

MsgStream & InDet::TRT_DetElementsRoadMaker_xk::dumpEvent ( MsgStream & out, int size_road )

staticprivate

Definition at line 244 of file TRT_DetElementsRoadMaker_xk.cxx.

{
  out<<"|--------------------------------------------------------------------|"
     <<std::endl;
  out<<"| Road size               | "<<std::setw(12)<<size_road
     <<"                             |"<<std::endl;
  out<<"|--------------------------------------------------------------------|"
     <<std::endl;
  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

finalize()

StatusCode InDet::TRT_DetElementsRoadMaker_xk::finalize ( )

overridevirtual

Implements InDet::ITRT_DetElementsRoadMaker.

Definition at line 78 of file TRT_DetElementsRoadMaker_xk.cxx.

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

get_bounds()

const Trk::CylinderBounds InDet::TRT_DetElementsRoadMaker_xk::get_bounds ( const EventContext & ctx ) const

inlineprivate

Definition at line 149 of file TRT_DetElementsRoadMaker_xk.h.

                                                                         {
        SG::ReadCondHandle<TRT_DetElementsRoadData_xk> roadData(m_roadDataKey, ctx);
        if (not roadData.isValid()) {
          ATH_MSG_FATAL("Failed to get " << m_roadDataKey.key());
        }
        return roadData->getBounds();
      }

getBound()

Trk::CylinderBounds InDet::TRT_DetElementsRoadMaker_xk::getBound ( MagField::AtlasFieldCache & fieldCache, const Trk::TrackParameters & Tp, const EventContext & ctx ) const

private

Definition at line 548 of file TRT_DetElementsRoadMaker_xk.cxx.

{
  const double cor = 0.8;
 
  double zfield = 0.;
  if(m_fieldModeEnum!=Trk::NoField && fieldCache.solenoidOn()) {
    const Amg::Vector3D& pos = Tp.position();
    double f[3], p[3] ={pos[Amg::x],pos[Amg::y],pos[Amg::z]};
    fieldCache.getFieldZR  (p, f);
    zfield =  299.7925*f[2];
  }
 
  const Trk::CylinderBounds bounds = get_bounds(ctx);
 
  if( std::abs(zfield) < .0000001    ) return bounds;
 
  const AmgVector(5)&  Vp = Tp.parameters();
 
  double cur  = zfield*Vp[4]/std::sin(Vp[3]);
 
  if( std::abs(cur)*bounds.r() < cor ) return bounds;
 
  double rad  = 1./cur;
  if(cor*std::abs(rad) > bounds.r()  ) return bounds;
 
  const  Amg::Vector3D& Gp = Tp.position()  ;
  double sn,cs; sincos(Vp[2],&sn,&cs);
  double xc   = Gp.x()+sn*rad            ;
  double yc   = Gp.y()-cs*rad            ;
  double rm   = (std::sqrt(xc*xc+yc*yc)+std::abs(rad))*cor;
  if( rm          > bounds.r()   ) return bounds;
  Trk::CylinderBounds CB(rm,bounds.halflengthZ());
  return CB;
}

getLayers()

const TRT_DetElementsLayerVectors_xk * InDet::TRT_DetElementsRoadMaker_xk::getLayers ( const EventContext & ctx ) const

inlineprivate

Definition at line 140 of file TRT_DetElementsRoadMaker_xk.h.

                                                                                     {
         SG::ReadCondHandle<TRT_DetElementsRoadData_xk> roadData(m_roadDataKey, ctx);
         if (not roadData.isValid()) {
            ATH_MSG_FATAL("Failed to get " << m_roadDataKey.key());
         }
         return roadData->getLayers();
      }

getTRTMinR()

double InDet::TRT_DetElementsRoadMaker_xk::getTRTMinR ( const EventContext & ctx ) const

inlineprivate

Definition at line 158 of file TRT_DetElementsRoadMaker_xk.h.

                                                        {
        SG::ReadCondHandle<TRT_DetElementsRoadData_xk> roadData(m_roadDataKey, ctx);
        if (not roadData.isValid()) {
          ATH_MSG_FATAL("Failed to get " << m_roadDataKey.key());
        }
        double rmintrt = roadData->getTRTMinR();
        return rmintrt;
      }

initialize()

StatusCode InDet::TRT_DetElementsRoadMaker_xk::initialize ( )

overridevirtual

Implements InDet::ITRT_DetElementsRoadMaker.

Definition at line 59 of file TRT_DetElementsRoadMaker_xk.cxx.

{
  StatusCode sc = AlgTool::initialize();
  if(m_fieldmode == "NoField") m_fieldModeEnum = Trk::NoField;
  else if(m_fieldmode == "MapSolenoid") m_fieldModeEnum = Trk::FastField;
  else m_fieldModeEnum = Trk::FullField;
  // Get propagator tool
  ATH_CHECK (m_proptool.retrieve());
  ATH_MSG_DEBUG("Retrieved tool " << m_proptool);
  ATH_CHECK(m_roadDataKey.initialize());
  ATH_CHECK( m_fieldCacheCondObjInputKey.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_DetElementsRoadMaker::interfaceID ( )

inlinestaticinherited

Definition at line 88 of file ITRT_DetElementsRoadMaker.h.

    {
      return IID_ITRT_DetElementsRoadMaker;
    }

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

stepToDetElement()

double InDet::TRT_DetElementsRoadMaker_xk::stepToDetElement ( const InDetDD::TRT_BaseElement *& de, Amg::Vector3D & r, Amg::Vector3D & a )

staticprivate

Definition at line 535 of file TRT_DetElementsRoadMaker_xk.cxx.

{
  Amg::Vector3D R  = de->center();
  Amg::Vector3D A  = de->normal();
  double      D  = a.x()*A.x()+a.y()*A.y()+a.z()*A.z(); if(D==0.) return D;
  return  ((A.x()*(R.x()-r.x())+A.y()*(R.y()-r.y())+A.z()*(R.z()-r.z()))/D);
}

sysInitialize()

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

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

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

overridevirtualinherited

Handle START transition.

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

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_fieldCacheCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> InDet::TRT_DetElementsRoadMaker_xk::m_fieldCacheCondObjInputKey

private

Initial value:

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

Definition at line 102 of file TRT_DetElementsRoadMaker_xk.h.

                                                                              {this,"AtlasFieldCacheCondObj", "fieldCondObj",
        "Name of the Magnetic Field conditions object key"}; // Necessary only for dumpConditions method

m_fieldmode

StringProperty InDet::TRT_DetElementsRoadMaker_xk::m_fieldmode

private

Initial value:

{this, "MagneticFieldMode", "MapSolenoid",
    "Mode of magnetic field"}

Definition at line 112 of file TRT_DetElementsRoadMaker_xk.h.

                                {this, "MagneticFieldMode", "MapSolenoid",
    "Mode of magnetic field"};

m_fieldModeEnum

Trk::MagneticFieldMode InDet::TRT_DetElementsRoadMaker_xk::m_fieldModeEnum {Trk::FullField}

private

Definition at line 114 of file TRT_DetElementsRoadMaker_xk.h.

{Trk::FullField};

m_proptool

PublicToolHandle<Trk::IPropagator> InDet::TRT_DetElementsRoadMaker_xk::m_proptool

private

Initial value:

{this, "PropagatorTool",
        "Trk::RungeKuttaPropagator/InDetPropagator"}

Definition at line 105 of file TRT_DetElementsRoadMaker_xk.h.

                                                 {this, "PropagatorTool",
        "Trk::RungeKuttaPropagator/InDetPropagator"};

m_roadDataKey

SG::ReadCondHandleKey<TRT_DetElementsRoadData_xk> InDet::TRT_DetElementsRoadMaker_xk::m_roadDataKey

private

Initial value:

{this, "RoadDataKey",
        "TRT_DetElementsRoadData_xk", "Key of TRT_DetElementsRoadData_xk"}

Definition at line 99 of file TRT_DetElementsRoadMaker_xk.h.

                                                                   {this, "RoadDataKey",
        "TRT_DetElementsRoadData_xk", "Key of TRT_DetElementsRoadData_xk"};

m_step

DoubleProperty InDet::TRT_DetElementsRoadMaker_xk::m_step {this, "MaxStep", 20., "Max step allowed"}

private

Definition at line 110 of file TRT_DetElementsRoadMaker_xk.h.

{this, "MaxStep", 20., "Max step allowed"};

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_width

FloatProperty InDet::TRT_DetElementsRoadMaker_xk::m_width

private

Initial value:

{this, "RoadWidth", 10.,
    "Width of the roadInnerDetector/InDetRecTools/"}

Definition at line 108 of file TRT_DetElementsRoadMaker_xk.h.

                           {this, "RoadWidth", 10.,
    "Width of the roadInnerDetector/InDetRecTools/"};

---

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

• TRT_DetElementsRoadMaker_xk.h
• TRT_DetElementsRoadMaker_xk.cxx