Filter_Combined Class Reference

#include <Filters.h>

Inheritance diagram for Filter_Combined:

Collaboration diagram for Filter_Combined:

Public Member Functions
	Filter_Combined (TrackFilter *f1, TrackFilter *f2)
void	setRoi (TIDARoiDescriptor *r)
void	containtracks (bool b=true)
	set / unset the flag to determine whether tracks should be fully contained in the RoI or not More...
void	containtracksPhi (bool b=true)
	set / unset to allow the strict phi containment to be used even if the full rigorous containement is not More...
bool	contains (const TIDA::Track *t, const TIDARoiDescriptor *r) const
bool	select (const TIDA::Track *t, const TIDARoiDescriptor *r=0)
void	setDebug (bool b)

Static Public Member Functions
static double	outerphi (double pt, double phi, double r=1000)
	calculate the (very approximate) phi position for a track at a rafius r More...

Private Attributes
TrackFilter *	m_f1
TrackFilter *	m_f2
const TIDARoiDescriptor *	m_roi
bool	m_debugPrintout
bool	m_containPhi
bool	m_contain

Detailed Description

Definition at line 225 of file Filters.h.

Constructor & Destructor Documentation

Filter_Combined()

Filter_Combined::Filter_Combined ( TrackFilter *  f1, TrackFilter *  f2  )

inline

Definition at line 229 of file Filters.h.

                                                     : 
    m_f1(f1), m_f2(f2), m_roi(0), 
    m_debugPrintout(false), 
    m_containPhi(true),
    m_contain(false)
  { } 

Member Function Documentation

contains()

bool Filter_Combined::contains ( const TIDA::Track *  t, const TIDARoiDescriptor *  r  ) const

inline

NB: This isn't actually correct - the tracks can bend out of the Roi even it the perigee phi is withing the Roi

NB: This is completely wrong, tracks could be completely contained within an Roi but failthis condition

includes calculation of approximate z position of the track at radius r and test if track within that z position at radius r

full check to determine whether a track is
fully contained in the Roi or not (when used in conjunction with contained_zed above)

now check phi taking account of the track transverse curvature

Definition at line 250 of file Filters.h.

                                                                        { 
 
    if ( r==0 ) { 
      std::cerr << "Filter_Combined::contains() called with null roidescriptor" << std::endl;
      return true;
    }
 
    if ( r->composite() ) {       
      for ( unsigned i=r->size() ; i-- ; )  if ( contains( t, r->at(i) ) ) return true;
    }
    else { 
 
      if ( r->isFullscan() ) return true;
 
      bool contained_phi = false;
      
      if ( r->phiMinus()<r->phiPlus() )  contained_phi = ( t->phi()>r->phiMinus() &&  t->phi()<r->phiPlus() );
      else                           contained_phi = ( t->phi()>r->phiMinus() ||  t->phi()<r->phiPlus() ); 
      
      bool contained_zed = ( t->z0()>r->zedMinus() && t->z0()<r->zedPlus() ); 
 
      bool contained_eta = ( t->eta()<r->etaPlus() && t->eta()>r->etaMinus() );
      
      if ( m_contain || m_containPhi ) { 
 
       
    double rexit = 0;
    double zexit = 0;
 
    //  double tantheta = TIDARoiDescriptor::exitpoint( t->z0(), t->eta(), zexit, rexit );
 
    TIDARoiDescriptor::exitpoint( t->z0(), t->eta(), zexit, rexit );
 
 
    double cross0 = zexit*r->rMinusZed() - rexit*r->zedMinusR();
    double cross1 = zexit*r->rPlusZed()  - rexit*r->zedPlusR(); 
    
    if ( m_contain ) {  
      if ( cross0>0 && cross1<0 ) contained_eta=true;
      else                        contained_eta=false;
    }
 
 
    double newphi = outerphi( t->pT(), t->phi(), rexit );
    
    if ( newphi==0 ) return false;
    
    if ( r->phiMinus()<r->phiPlus() ) contained_phi &= ( newphi>r->phiMinus() &&  newphi<r->phiPlus() );
    else                              contained_phi &= ( newphi>r->phiMinus() ||  newphi<r->phiPlus() );
 
      }
 
      if ( contained_eta  && 
       contained_phi  &&
       contained_zed  ) { 
    if ( m_debugPrintout ) std::cout << "\tFilter::inside roi" << std::endl;
    return true;
      }
      
    }
    
    return false;
 
  }

containtracks()

void Filter_Combined::containtracks ( bool  b = true )

inline

set / unset the flag to determine whether tracks should be fully contained in the RoI or not

Definition at line 242 of file Filters.h.

{ m_contain=b; }

containtracksPhi()

void Filter_Combined::containtracksPhi ( bool  b = true )

inline

set / unset to allow the strict phi containment to be used even if the full rigorous containement is not

Definition at line 247 of file Filters.h.

{ m_containPhi=b; }

outerphi()

static double Filter_Combined::outerphi ( double  pt, double  phi, double  r = 1000  )

inlinestatic

calculate the (very approximate) phi position for a track at a rafius r

track (signed) radius of curvature

make sure it escapes the radius in question

calculate new position

wrap to -pi to pi

Definition at line 356 of file Filters.h.

                                                                 {  
    
    
    double mqR = 10*pt/(2.99792458*2); // 2.998=speed of light, 2=Atlas B field 
    
    double ratio = 0.5*r/mqR;
    
    double newphi = phi;
    
    if ( std::fabs(ratio)>1 ) return 0; 
    
    newphi -= std::asin( ratio );  
    
    while ( newphi<-M_PI ) newphi += 2*M_PI;
    while ( newphi> M_PI ) newphi -= 2*M_PI;
    
    return newphi;
    
  }

select()

bool Filter_Combined::select ( const TIDA::Track *  t, const TIDARoiDescriptor *  r = 0  )

inlinevirtual

no roi so just return the and of the input filters

Implements TrackFilter.

Definition at line 326 of file Filters.h.

                                                                  {
 
    if ( r!=0 ) m_roi = r;
    
    if ( m_debugPrintout ) { 
      std::cout << "\tFilter: " << this << "\tfilter1 " << m_f1->select(t,m_roi) << "\tfilter2 " << m_f2->select(t,m_roi) << "\troi " << m_roi << std::endl;
    }
 
    if ( m_roi==0 ) return ( m_f1->select(t,r) && m_f2->select(t,r) );
    else {
 
      if ( m_debugPrintout ) { 
    std::cout << "\tFilter::filter1 " << m_f1->select(t,m_roi) << "\tfilter2 " << m_f2->select(t,m_roi) << "\troi " << *m_roi << std::endl; 
      }
 
      if ( contains( t, m_roi ) )  return ( m_f1->select(t,m_roi) && m_f2->select(t,m_roi) );
      else  return false;
 
    }
  }  

setDebug()

void Filter_Combined::setDebug ( bool  b )

inline

Definition at line 348 of file Filters.h.

{ m_debugPrintout=b; }  

setRoi()

void Filter_Combined::setRoi ( TIDARoiDescriptor *  r )

inline

Definition at line 236 of file Filters.h.

{ m_roi = r; } 

Member Data Documentation

m_contain

bool Filter_Combined::m_contain

private

Definition at line 391 of file Filters.h.

m_containPhi

bool Filter_Combined::m_containPhi

private

Definition at line 390 of file Filters.h.

m_debugPrintout

bool Filter_Combined::m_debugPrintout

private

Definition at line 388 of file Filters.h.

m_f1

TrackFilter* Filter_Combined::m_f1

private

Definition at line 383 of file Filters.h.

m_f2

TrackFilter* Filter_Combined::m_f2

private

Definition at line 384 of file Filters.h.

m_roi

const TIDARoiDescriptor* Filter_Combined::m_roi

private

Definition at line 386 of file Filters.h.

---

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

• Filters.h