Filter< Variable, RangeType, Observer > Class Template Reference

Basic Filter ///. More...

#include <Filter.h>

Inheritance diagram for Filter< Variable, RangeType, Observer >:

Public Types
typedef Variable::argumentType	argumentType
	Handy typedef for arguments.
typedef Variable::functionType	functionType
	Handy typedef for function.

Public Member Functions
	Filter (const RangeType &range)
	Constructor.
	Filter ()=default
	Empty constructor.
RangeType	getRange (void) const
	Getter of the range.
template<typename ... argsType>
std::enable_if< all_same< argumentType, argsType... >::value, bool >::type	accept (const argsType &... args) const
	The accept method of the filter: All the real computations are occuring in this method.
void	persist (TTree *t, const std::string &branchName)
	Persist the range on a TTree.
void	setBranchAddress (TTree *t, const std::string &branchName)
	Set the Branches addresses to this filter.
Filter< Variable, RangeType, BypassableFilter, Observer >	bypass (const bool &bypassVariable=false)
	This method creates a new bypassable Filter with the same range of *this E.g.:
Filter< Variable, RangeType, ActivatableFilter, Observer >	enable (const bool &enableVariable=true)
	Create a new activatable filter.
template<class otherObserver >
Filter< Variable, RangeType, otherObserver >	observeLeaf (const otherObserver &) const
	Function to observer of a filter.
template<class otherObserver >
	Filter (const Filter< Variable, RangeType, otherObserver > &filter)
	Copy constructor for filter.
std::string	getNameAndReference (std::vector< std::pair< char, void * > > *pointers=nullptr)
	Getter for name of and reference to the range of the filters.

Protected Attributes
RangeType	m_range
	Member range of the filter.

Detailed Description

template<class Variable, class RangeType, class Observer>
class Belle2::Filter< Variable, RangeType, Observer >

Basic Filter ///.

Basic building block of the Filter tools Example usage:

#include <tracking/trackFindingVXD/filterMap/filterFramework/SelectionVariable.h>
#include <tracking/trackFindingVXD/filterMap/filterFramework/UpperBoundedSet.h>
#include <tracking/trackFindingVXD/filterMap/filterFramework/Filter.h>
 
struct spacePoint{ float x; float y; float z; };
 
SquaredDistance2D: public SelectionVariable<TSpacePoint> {
  value(const TSpacePoint & p1, const TSpacePoint &p2){
    return pow(p1.x - p2.x, 2) + pow(p1.y - p2.y, 2);
  }
};
Filter<SquaredDistance2D, UpperBoundedSet, VoidObserver> filter(UpperBoundedSet( 1.1 ));
 
spacePoint a( {0,0,0} ), b( {1,0,0} );
cout << filter.accept(a,b) << endl;

will produce the output: true The Variable class will provide the static method value x( arg1, arg2) The RangeType object will provide the method contains to decide if x(arg1, arg2) is good The Observer will be notified of the actions via its static method notify

Definition at line 113 of file Filter.h.

Member Typedef Documentation

argumentType

typedef Variable::argumentType argumentType

Handy typedef for arguments.

Definition at line 116 of file Filter.h.

functionType

typedef Variable::functionType functionType

Handy typedef for function.

Definition at line 119 of file Filter.h.

Constructor & Destructor Documentation

Filter() [1/2]

Filter ( const RangeType &  range )

inlineexplicit

Constructor.

To construct the Filter we need a concrete RangeType. The variable and the observer are passed through the template type pack.

Parameters

range

a class that provides a method contains such as: bool contains(Variable::returnType x)

Definition at line 128 of file Filter.h.

                                           :
      m_range(range) { };

Filter() [2/2]

Filter ( const Filter< Variable, RangeType, otherObserver > &  filter )

inline

Copy constructor for filter.

Template Parameters

otherObserver

observer type

Parameters

filter

filter to be copied

Definition at line 243 of file Filter.h.

                                                                    :
      m_range(filter.getRange()) {};

Member Function Documentation

accept()

std::enable_if< all_same< argumentType, argsType... >::value, bool >::type accept ( const argsType &...  args ) const

inline

The accept method of the filter: All the real computations are occuring in this method.

Template Parameters

argsType

template arguments depending on the filter

Parameters

args	values to be tested by the filters

Returns

boolean indicating if filter is passed This typename expands to bool only if all the argsType are of the same type of the argument of the filter

Definition at line 149 of file Filter.h.

    {
      typename Variable::variableType value = Variable::value(args ...);
      Observer::notify(Variable(), value, m_range, args ...);
      return m_range.contains(value);
    }

bypass()

Filter< Variable, RangeType, BypassableFilter, Observer > bypass ( const bool &  bypassVariable = false )

inline

This method creates a new bypassable Filter with the same range of *this E.g.:

#include <tracking/trackFindingVXD/filterMap/filterFramework/SelectionVariable.h>
#include <tracking/trackFindingVXD/filterMap/filterFramework/UpperBoundedSet.h>
#include <tracking/trackFindingVXD/filterMap/filterFramework/Filter.h>
 
struct spacePoint{ float x; float y; float z; };
 
SquaredDistance2D: public SelectionVariable<TSpacePoint> {
value(const TSpacePoint & p1, const TSpacePoint &p2){
  return pow(p1.x - p2.x, 2) + pow(p1.y - p2.y, 2);
}
};
Filter<SquaredDistance2D, UpperBoundedSet, VoidObserver> filter(UpperBoundedSet( 1.1 ));
bool bypassVariable(false);
auto bypassableFilter( filter.bypass( bypassVariable ) );
 
spacePoint a( {0,0,0} ), b( {10,0,0} );
cout << bypassableFilter.accept(a,b) << endl;
bypassVariable = true;
cout << bypassableFilter.accept(a,b) << endl;

will produce: false true

Definition at line 208 of file Filter.h.

    {
      return Filter<Variable, RangeType, BypassableFilter, Observer>(m_range, bypassVariable);
    }

enable()

Filter< Variable, RangeType, ActivatableFilter, Observer > enable ( const bool &  enableVariable = true )

inline

Create a new activatable filter.

Parameters

enableVariable

If the filter is active

Returns

filter

Definition at line 220 of file Filter.h.

    {
      return Filter<Variable, RangeType, ActivatableFilter, Observer>(m_range, enableVariable);
    }

getNameAndReference()

std::string getNameAndReference ( std::vector< std::pair< char, void * > > *  pointers = nullptr )

inline

Getter for name of and reference to the range of the filters.

Calls getNameAndReference of RangeType.

Parameters

pointers

pointer to vector of pairs of names of and pointers to the filters

Returns

string containing name of the variable and the bounds of the range (see RangeTypes)

Definition at line 252 of file Filter.h.

    {
      return m_range.getNameAndReference(pointers, Variable::name());
    }

getRange()

RangeType getRange ( void  ) const

inline

Getter of the range.

Definition at line 136 of file Filter.h.

{ return m_range; }

observeLeaf()

Filter< Variable, RangeType, otherObserver > observeLeaf ( const otherObserver &  ) const

inline

Function to observer of a filter.

Template Parameters

otherObserver

observer to be used

Returns

filter with the respective observer

Definition at line 232 of file Filter.h.

    {
      return Filter<Variable, RangeType, otherObserver>(m_range);
    }

persist()

void persist ( TTree *  t, const std::string &  branchName  )

inline

Persist the range on a TTree.

Parameters

t	is the TTree under which the TBranch will be created
branchName	is the name of the TBranch holding m_range

Definition at line 161 of file Filter.h.

    {
      m_range.persist(t, branchName, Variable().name());
    }

setBranchAddress()

void setBranchAddress ( TTree *  t, const std::string &  branchName  )

inline

Set the Branches addresses to this filter.

Parameters

t	is the TTree containing the TBranch
branchName	is the name of the TBranch holding the m_range

Definition at line 171 of file Filter.h.

    {
      m_range.setBranchAddress(t, branchName, Variable().name());
    }

Member Data Documentation

m_range

RangeType m_range

protected

Member range of the filter.

Definition at line 259 of file Filter.h.

---

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

• tracking/trackFindingVXD/filterMap/filterFramework/include/Filter.h