InDet::SeedFitterTool Class Reference

Estimate the initial track parameters for a list of spacepoints/measurements (i.e. Track candidates), which latter can be used as input for the track fitter. The method is based on a simple linear conformal mapping. More...

#include <SeedFitterTool.h>

Inheritance diagram for InDet::SeedFitterTool:

Collaboration diagram for InDet::SeedFitterTool:

Public Member Functions
	SeedFitterTool (const std::string &, const std::string &, const IInterface *)
virtual std::unique_ptr< const Trk::TrackParameters >	fit (const std::vector< const Trk::SpacePoint * > &spacepoints) const override
virtual MsgStream &	dump (MsgStream &out) const override
virtual std::ostream &	dump (std::ostream &out) const override
MsgStream &	dumpevent (MsgStream &out) const

Protected Member Functions
	SeedFitterTool ()=delete
	SeedFitterTool (const SeedFitterTool &)=delete
SeedFitterTool &	operator= (const SeedFitterTool &)=delete

Detailed Description

Estimate the initial track parameters for a list of spacepoints/measurements (i.e. Track candidates), which latter can be used as input for the track fitter. The method is based on a simple linear conformal mapping.

Author

xiang.nosp@m.yang.nosp@m..ju@c.nosp@m.ern..nosp@m.ch

Definition at line 22 of file SeedFitterTool.h.

Constructor & Destructor Documentation

SeedFitterTool() [1/3]

InDet::SeedFitterTool::SeedFitterTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Definition at line 11 of file SeedFitterTool.cxx.

                                                                         :
    base_class(type, name, parent)
{
  declareInterface<ISeedFitter>(this);
}

SeedFitterTool() [2/3]

InDet::SeedFitterTool::SeedFitterTool ( )

protecteddelete

SeedFitterTool() [3/3]

InDet::SeedFitterTool::SeedFitterTool ( const SeedFitterTool &  )

protecteddelete

Member Function Documentation

dump() [1/2]

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

overridevirtual

Definition at line 120 of file SeedFitterTool.cxx.

{
  out<<std::endl;
  return dumpevent(out);
}

dump() [2/2]

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

overridevirtual

Definition at line 126 of file SeedFitterTool.cxx.

{
  return out;
}

dumpevent()

MsgStream & InDet::SeedFitterTool::dumpevent

(

MsgStream &

out

)

const

Definition at line 131 of file SeedFitterTool.cxx.

{
  out<<"|Nothing to dump-|"
       <<std::endl;
  return out;
}

fit()

std::unique_ptr< const Trk::TrackParameters > InDet::SeedFitterTool::fit ( const std::vector< const Trk::SpacePoint * > &  spacepoints ) const

overridevirtual

get the first cluster on the first hit

and use the surface from this cluster as our reference plane

local x of the surface in the global frame

local y of the surface in the global frame

centre of the surface in the global frame

location of the first SP w.r.t centre of the surface

local x, y - coordinates of the first SP in the local frame

Definition at line 18 of file SeedFitterTool.cxx.

{
 
 
  if (spacePoints.size() < 3) {
    return nullptr;
  }
 
  const Trk::PrepRawData*       cl  = spacePoints[0]->clusterList().first;
  if(!cl) return nullptr;
  const Trk::PlaneSurface*      pla = 
    static_cast<const Trk::PlaneSurface*>(&cl->detectorElement()->surface());
  if(!pla) return nullptr;
 
  // translate second and third SP w.r.t first one
  double x0 = spacePoints[0]->globalPosition().x();
  double y0 = spacePoints[0]->globalPosition().y();
  double z0 = spacePoints[0]->globalPosition().z();
 
  double x1 = spacePoints[1]->globalPosition().x() - x0;
  double y1 = spacePoints[1]->globalPosition().y() - y0;
 
  double x2 = spacePoints[2]->globalPosition().x() - x0;
  double y2 = spacePoints[2]->globalPosition().y() - y0;
  double z2 = spacePoints[2]->globalPosition().z() - z0; 
 
  // distance of second SP to first in transverse plane
  // Also happens to be u-coordinate of second SP in conformal mapping
  double u1 = 1./std::sqrt(x1*x1+y1*y1);
  // denominator for conformal mapping
  double rn = x2*x2+y2*y2;
  double r2 = 1./rn;
  // coordinate system for conformal mapping - this is local x
  double a  = x1*u1;
  double b  = y1*u1;
  // u/v-coordinate of third SP in conformal mapping
  double u2 = (a*x2+b*y2)*r2;
  double v2 = (a*y2-b*x2)*r2;
  // A,B are slope and intercept of the straight line in the u,v plane
  // connecting the three points.
  double A  = v2/(u2-u1);
  double T = z2*sqrt(r2); 
 
  const Amg::Transform3D& Tp = pla->transform();
 
  double Ax[3] = {Tp(0,0),Tp(1,0),Tp(2,0)}; 
  double Ay[3] = {Tp(0,1),Tp(1,1),Tp(2,1)}; 
  double D [3] = {Tp(0,3),Tp(1,3),Tp(2,3)}; 
  double   d[3] = {x0-D[0],y0-D[1],z0-D[2]};
 
  double track_paras[5];
  track_paras[0] = d[0]*Ax[0]+d[1]*Ax[1]+d[2]*Ax[2];
  track_paras[1] = d[0]*Ay[0]+d[1]*Ay[1]+d[2]*Ay[2];
  track_paras[2] = std::atan2(b+a*A, a-b*A);
  track_paras[3] = std::atan2(1.,T) ;
  track_paras[4] = 0.001/std::sqrt(1.+T*T);  // qoverp from qoverpt and theta
 
  ATH_MSG_DEBUG(
      "linearConformalMapping: \n" << \
      "\nlocal x = " << track_paras[0] << \
      "\nlocal y = " << track_paras[1] << \
      "\nphi     = " << track_paras[2] << \
      "\ntheta   = " << track_paras[3] << \
      "\nqoverp  = " << track_paras[4]);
 
  bool any_nan = false;
  for (int i = 0; i < 5; i++) {
    if (std::isnan(track_paras[i])) {
      any_nan = true;
      break;
    }
  }
  if (any_nan){
      ATH_MSG_DEBUG("Seed parameters contain NaN elements - skipping this track ");
      return nullptr; 
  }
 
  std::unique_ptr<const Trk::TrackParameters> trkParameters(
    pla->createUniqueTrackParameters(track_paras[0],track_paras[1],track_paras[2],track_paras[3],track_paras[4],std::nullopt));
  
  if (!trkParameters) {
    ATH_MSG_DEBUG("Failed to create track parameters");
    return nullptr;
  }
 
  return trkParameters;
}

operator=()

SeedFitterTool& InDet::SeedFitterTool::operator= ( const SeedFitterTool &  )

protecteddelete

---

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

• SeedFitterTool.h
• SeedFitterTool.cxx