Track filter for the bridging methods. More...

#include <QwBridgingTrackFilter.h>

Public Types
enum	EStatus { kPass = 0, kFailThetaFront, kFailThetaBack, kFailPhiFront, kFailPhiBack, kFailDiffTheta, kFailDiffPhi, kFailVertexZ, kFailUnknown }
	List of possible failure modes for the filter. More...

Public Member Functions
	QwBridgingTrackFilter ()
	Default constructor. More...

virtual	~QwBridgingTrackFilter ()
	Destructor. More...

EStatus	Filter (const QwPartialTrack front, const QwPartialTrack back) const
	Filter front and back track combinations. More...

Private Attributes
double	fMinTheta
	Angle and position boundaries for the filter. More...

double	fMaxTheta

double	fMinPhi

double	fMaxPhi

double	fMinDiffTheta

double	fMaxDiffTheta

double	fMinDiffPhi

double	fMaxDiffPhi

double	fMinVertexZ

double	fMaxVertexZ

Detailed Description

Track filter for the bridging methods.

Not all combinations of front and back tracks lead to a valid bridged track. This object filters combinations of front and back tracks and only accepts combinations that satisfy certain criteria.

Definition at line 32 of file QwBridgingTrackFilter.h.

Member Enumeration Documentation

enum QwBridgingTrackFilter::EStatus

List of possible failure modes for the filter.

Enumerator
kPass
kFailThetaFront
kFailThetaBack
kFailPhiFront
kFailPhiBack
kFailDiffTheta
kFailDiffPhi
kFailVertexZ
kFailUnknown

Definition at line 42 of file QwBridgingTrackFilter.h.

                  {
       kPass = 0,
       kFailThetaFront,
       kFailThetaBack,
       kFailPhiFront,
       kFailPhiBack,
       kFailDiffTheta,
       kFailDiffPhi,
       kFailVertexZ,
       kFailUnknown
     };

Constructor & Destructor Documentation

QwBridgingTrackFilter::QwBridgingTrackFilter ( )

Default constructor.

Definition at line 11 of file QwBridgingTrackFilter.cc.

References Qw::cm, Qw::deg, fMaxDiffPhi, fMaxDiffTheta, fMaxPhi, fMaxTheta, fMaxVertexZ, fMinDiffPhi, fMinDiffTheta, fMinPhi, fMinTheta, and fMinVertexZ.

 {
   // Set default filter criteria
   // - polar angle, should probably be split in front and back
   fMinTheta = 1.0 * Qw::deg;
   fMaxTheta = 13.0 * Qw::deg;
   // - difference in polar angle between front and back
   fMinDiffTheta = 5.0 * Qw::deg;
   fMaxDiffTheta = 45.0 * Qw::deg;
   // - azimuthal angle
   fMinPhi = 0.0 * Qw::deg;
   fMaxPhi = 360.0 * Qw::deg;
   // - difference in azimuthal angle between front and back
   fMinDiffPhi = - 20.0 * Qw::deg;
   fMaxDiffPhi =   20.0 * Qw::deg;
   // - longitudinal vertex position in target
   fMinVertexZ = -672.0 * Qw::cm;
   fMaxVertexZ = -628.0 * Qw::cm;
 }

virtual QwBridgingTrackFilter::~QwBridgingTrackFilter ( )

inlinevirtual

Destructor.

Definition at line 39 of file QwBridgingTrackFilter.h.

39 { };

Member Function Documentation

QwBridgingTrackFilter::EStatus QwBridgingTrackFilter::Filter	(	const QwPartialTrack *	front,
		const QwPartialTrack *	back
	)		const

Filter front and back track combinations.

Filter combinations of front and back partial tracks before bridging

Parameters

front	Front partial track
back	Back partial track

Returns: Failure code (zero when accepted)

Definition at line 40 of file QwBridgingTrackFilter.cc.

References Qw::cm, Qw::deg, QwLog::endl(), fMaxDiffPhi, fMaxDiffTheta, fMaxTheta, fMaxVertexZ, fMinDiffPhi, fMinDiffTheta, fMinTheta, QwPartialTrack::fOffsetX, QwPartialTrack::fOffsetY, QwPartialTrack::fSlopeX, QwPartialTrack::fSlopeY, QwPartialTrack::GetMomentumDirection(), QwPartialTrack::GetMomentumDirectionPhi(), QwPartialTrack::GetMomentumDirectionTheta(), QwPartialTrack::GetPosition(), kFailDiffPhi, kFailDiffTheta, kFailThetaFront, kFailVertexZ, kPass, and QwDebug.

Referenced by main(), and QwTrackingWorker::ProcessEvent().

 {
     // NOTE The angle limits will be determined from MC simulation results
 
     // Scattering angle limit
     double theta = front->GetMomentumDirectionTheta();
     if ((theta < fMinTheta) || (theta > fMaxTheta)) {
         QwDebug << "QwBridgingTrackFilter: theta = " << theta/Qw::deg << " deg, "
                 << "allowed range [" << fMinTheta/Qw::deg << ","
                                      << fMaxTheta/Qw::deg << "] deg" << QwLog::endl;
         return kFailThetaFront;
     }
 
     // Bending angle limits in the magnetic field
     double dtheta = (back->GetMomentumDirectionTheta() - front->GetMomentumDirectionTheta());
     if ((dtheta < fMinDiffTheta) || (dtheta > fMaxDiffTheta)) {
       // QwMessage << "QwBridgingTrackFilter: dtheta = " << dtheta/Qw::deg << " deg, "
       //            << "allowed range [" << fMinDiffTheta/Qw::deg << ","
       //                                 << fMaxDiffTheta/Qw::deg << "] deg" << QwLog::endl;
         return kFailDiffTheta;
     }
     double dphi = (back->GetMomentumDirectionPhi() - front->GetMomentumDirectionPhi());
     if ((dphi < fMinDiffPhi) || (dphi > fMaxDiffPhi)) {
       //  QwMessage << "QwBridgingTrackFilter: dphi = " << dphi/Qw::deg << " deg, "
       //            << "allowed range [" << fMinDiffPhi/Qw::deg << ","
       //                                       << fMaxDiffPhi/Qw::deg << "] deg" << QwLog::endl;
         return kFailDiffPhi;
     }
 
     // Scattering vertex limits and position phi limits (QTOR keep-out zone)
     TVector3 start_position = front->GetPosition(-330.685 * Qw::cm);
     TVector3 start_direction = front->GetMomentumDirection();
     // front track position and angles at z = -250 cm plane
     //double r = fabs(start_position.Z() - (-250.0 * Qw::cm)) / start_direction.Z(); // unused
     //double x = start_position.X() + r * start_direction.X(); // unused
     //double y = start_position.Y() + r * start_direction.Y(); // unused
 
     //    double position_r = sqrt(x*x + y*y);
     double position_phi = start_position.Phi();
     //double direction_theta = direction_theta = front->GetMomentumDirectionTheta(); // unused
 
     //double vertex_z = -250.0 * Qw::cm - position_r / tan(acos(start_direction.Z()));
     double vertex_z=-(front->fSlopeX*front->fOffsetX + front->fSlopeY*front->fOffsetY)/(front->fSlopeX*front->fSlopeX+front->fSlopeY*front->fSlopeY);
     if (vertex_z < fMinVertexZ || vertex_z > fMaxVertexZ) {
       //   QwMessage << "QwBridgingTrackFilter: vertex z = " << vertex_z/Qw::cm << " cm, "
       //            << "allowed range [" << fMinVertexZ/Qw::cm << ","
       //                                 << fMaxVertexZ/Qw::cm << "] cm" << QwLog::endl;
         return kFailVertexZ;
     }
 
     // scattering angle phi and the position_phi at Region 2 should have very small difference
     // this will post a limit on the phi difference
     double direction_phi = 0.0;
     direction_phi = front->GetMomentumDirectionPhi();
     double delta_front_phi = fabs(direction_phi - position_phi);
     if (delta_front_phi> 5.0*Qw::deg) {
       //   QwMessage << "QwBridgingTrackFilter: delta_front_phi = " << delta_front_phi/Qw::deg << " deg, "
       //            << "allowed range [-5, 5] cm" << QwLog::endl;
         return kFailVertexZ;
     }
 
     // TODO: add in QTOR keep-out zones
 
     return kPass;
 }