Class that contains all the static sectors to which the filters are attached. More...

#include <VXDTFFilters.h>

Public Types
typedef decltype((0.<=DistanceInTimeUside< point_t >()<=0. &&0.<=DistanceInTimeVside< point_t >()<=0. &&0.<=Distance3DSquared< point_t >()<=0.&&0.<=Distance2DXYSquared< point_t >()<=0.&&0.<=Distance1DZ< point_t >()<=0.&&0.<=SlopeRZ< point_t >()<=0.&&0.<=Distance3DNormed< point_t >()<=0.))	twoHitFilter_t
	minimal working 2-hits-example used for redesign of VXDTF.

typedef decltype((0.<=DistanceInTime< point_t >()<=0. &&0.<=Angle3DSimple< point_t >()<=0.&&0.<=CosAngleXY< point_t >()<=0.&&0.<=AngleRZSimple< point_t >()<=0.&&CircleDist2IP< point_t >()<=0.&&0.<=DeltaSlopeRZ< point_t >()<=0.&&0.<=DeltaSlopeZoverS< point_t >()<=0.&&0.<=DeltaSoverZ< point_t >()<=0.&&0.<=HelixParameterFit< point_t >()<=0.&&0.<=Pt< point_t >()<=0.&&0.<=CircleRadius< point_t >()<=0.))	threeHitFilter_t
	minimal working example for 3-hits:

typedef StaticSector< point_t, twoHitFilter_t, threeHitFilter_t, int >	staticSector_t
	typedef to make a static sector type more readable.

Public Member Functions
	VXDTFFilters ()
	Construct the container of all the filters used by the VXD Track Finder.

	~VXDTFFilters ()
	Destructor.

int	addSectorsOnSensor (const std::vector< double > &normalizedUsup, const std::vector< double > &normalizedVsup, const std::vector< std::vector< FullSecID > > &sectorIds)
	To add an array of sectors on a sensor.

int	addTwoHitFilter (FullSecID outer, FullSecID inner, const twoHitFilter_t &filter)
	adds a two hit filter

int	addThreeHitFilter (FullSecID outer, FullSecID center, FullSecID inner, const threeHitFilter_t &filter)
	adds a three hit filter

CompactSecIDs::sectorID_t	getCompactID (FullSecID outer) const
	returns compactSecID for given FullSecID, == 0 if not found.

const staticSector_t *	getStaticSector (const FullSecID secID) const
	returns pointer to static sector for given fullSecID.

const twoHitFilter_t	getTwoHitFilters (const FullSecID &outer, const FullSecID &inner) const
	retrieves a two hit filter:

bool	areCoordinatesValid (VxdID aSensorID, double normalizedU, double normalizedV) const
	check if using getFullID() would be safe (true if it is safe):

FullSecID	getFullID (VxdID aSensorID, double normalizedU, double normalizedV) const
	returns fullSecID for given sensorID and local coordinates.

FullSecID	getFullID (CompactSecIDs::sectorID_t compactSecID) const
	returns the FullSecId of

const SectorMapConfig &	getConfig (void) const
	returns the configuration settings for this VXDTFFilters.

void	setConfig (const SectorMapConfig &config)
	set the configuration which is used to create this filter

const CompactSecIDs &	getCompactIDsMap () const
	JKL: intended for some checks only - returns CompactIDsMap storing the static sectors.

const std::vector< staticSector_t * > &	getStaticSectors () const
	JKL: intended for some checks only - returns CompactIDsMap storing the static sectors.

unsigned	size () const
	returns number of compact secIDs stored for this filter-container.

bool	persistOnRootFile (void) const
	Persists (i.e.: writes) on the current TDirectory the whole object.

bool	retrieveFromRootFile (const TString *dirName)
	Retrieves from the current TDirectory all the VXDTFFilters.

bool	setSubLayerIDs (FullSecID sector, int sublayer)
	during the trainings phase the sublayer ids have to be updated

void	lockFilters ()
	This function should be called only AFTER all adjustments to the filters have been performed.

void	modify2SPFilters (const std::vector< std::tuple< int, std::string > > &adjustFunctions)
	modifies the 2SP-filters according to the functions given

void	modify3SPFilters (const std::vector< std::tuple< int, std::string > > &adjustFunctions)
	modifies the 3SP-filters according to the functions given

Private Member Functions
bool	persistSectors (void) const
	Persists all the sectors on the current TDirectory.

bool	retrieveSectors (const TString *dirName)
	Read the whole CompactSecIDs from the current TDirectory.

bool	persistFilters (void) const
	Persists on the current TDirectory the StaticSectors.

bool	retrieveFilters (const TString *dirName)
	Retrieves from the current TDirectory the StaticSectors.

int	addSectorsOnSensor (const std::vector< double > &normalizedUsup, const std::vector< double > &normalizedVsup, const std::vector< std::vector< unsigned int > > &fullSecIDsBaseType)
	Adds the static sector: TODO: need documentation for the parameters.

Private Attributes
CompactSecIDs	m_compactSecIDsMap
	This member takes care of converting the [layer][ladder] [sensor][sector] multi index into a linear index on the m_staticSectors vector.

std::vector< staticSector_t * >	m_staticSectors
	This vector contains all the static sectors on a sector map.

SectorMapConfig	m_testConfig
	Configuration: i.e.

const char *	c_CompactSecIDstreeName = "CompactSecIDs"
	name of the tree the SecIDs are stored in when persisted

bool	m_preventModification = false
	The filters are not supposed to be altered after initialization (typically in the Module::initialize() function).

Detailed Description

template<class point_t>
class Belle2::VXDTFFilters< point_t >

Class that contains all the static sectors to which the filters are attached.

It contains functions that are used to attach and retrieve filters. Also the type of the filters is defined in this class

Definition at line 63 of file VXDTFFilters.h.

Member Typedef Documentation

◆ staticSector_t

template<class point_t>

typedef StaticSector< point_t, twoHitFilter_t, threeHitFilter_t, int > staticSector_t

typedef to make a static sector type more readable.

Definition at line 117 of file VXDTFFilters.h.

◆ threeHitFilter_t

template<class point_t>

typedef decltype( ( 0. <= DistanceInTime<point_t>() <= 0. && 0. <= Angle3DSimple<point_t>() <= 0.&& 0. <= CosAngleXY<point_t>() <= 0.&& 0. <= AngleRZSimple<point_t>() <= 0.&& CircleDist2IP<point_t>() <= 0.&& 0. <= DeltaSlopeRZ<point_t>() <= 0.&& 0. <= DeltaSlopeZoverS<point_t>() <= 0.&& 0. <= DeltaSoverZ<point_t>() <= 0.&& 0. <= HelixParameterFit<point_t>() <= 0.&& 0. <= Pt<point_t>() <= 0.&& 0. <= CircleRadius<point_t>() <= 0. ) ) threeHitFilter_t

minimal working example for 3-hits:

big working example for 3-hits:

Definition at line 112 of file VXDTFFilters.h.

◆ twoHitFilter_t

template<class point_t>

typedef decltype( ( 0. <= DistanceInTimeUside<point_t>() <= 0. && 0. <= DistanceInTimeVside<point_t>() <= 0. && 0. <= Distance3DSquared<point_t>() <= 0.&& 0. <= Distance2DXYSquared<point_t>() <= 0.&& 0. <= Distance1DZ<point_t>() <= 0.&& 0. <= SlopeRZ<point_t>() <= 0.&& 0. <= Distance3DNormed<point_t>() <= 0. ) ) twoHitFilter_t

minimal working 2-hits-example used for redesign of VXDTF.

big working 2-hits-example used for redesign of VXDTF.

Definition at line 82 of file VXDTFFilters.h.

Constructor & Destructor Documentation

◆ VXDTFFilters()

template<class point_t>

VXDTFFilters ( )

inline

Construct the container of all the filters used by the VXD Track Finder.

Definition at line 120 of file VXDTFFilters.h.

                  : m_testConfig()
    {
      m_staticSectors.resize(2);
      // The first static sector is not used and will never be since the first
      // compact id is 1 and compact id = 0 is reserved to signal an error.
      m_staticSectors[0] = nullptr;
      // initialize the first slot of the Static sector vector
      m_staticSectors[1] = nullptr;
    }

◆ ~VXDTFFilters()

template<class point_t>

~VXDTFFilters ( )

inline

Destructor.

Definition at line 131 of file VXDTFFilters.h.

    {
      // delete the static sectors
      for (staticSector_t* aSector : m_staticSectors) if (aSector != nullptr) delete aSector;
    }

Member Function Documentation

◆ addSectorsOnSensor() [1/2]

template<class point_t>

int addSectorsOnSensor	(	const std::vector< double > &	normalizedUsup,
		const std::vector< double > &	normalizedVsup,
		const std::vector< std::vector< FullSecID > > &	sectorIds )

inline

To add an array of sectors on a sensor.

Parameters

normalizedUsup	and
normalizedVsup	are two vectors of double coding the geometry of the sectors.
sectorIds	is a rectangular matrix of FullSecID. It returns the number of sectors added to the compactSecIDsMap

Definition at line 142 of file VXDTFFilters.h.

    {
 
      auto addedSectors = m_compactSecIDsMap.addSectors(normalizedUsup,
                                                        normalizedVsup,
                                                        sectorIds);
 
      if ((int) addedSectors != ((int) normalizedVsup.size() + 1) *
          ((int) normalizedUsup.size() + 1))
        return addedSectors ;
 
      addedSectors = 0;
      try {
        for (const auto& secIDrow : sectorIds)
          for (auto secID : secIDrow) {
            auto compactID = m_compactSecIDsMap.getCompactID(secID);
 
            if ((int) m_staticSectors.size() <= compactID)
              m_staticSectors.resize(compactID + 1);
 
            m_staticSectors[ compactID ]  = new staticSector_t(secID) ;
            m_staticSectors[ compactID ]->assignCompactSecIDsMap(m_compactSecIDsMap);
 
            addedSectors ++;
          }
      } catch (...) { return addedSectors ; }
 
      return addedSectors;
    }

◆ addSectorsOnSensor() [2/2]

template<class point_t>

int addSectorsOnSensor	(	const std::vector< double > &	normalizedUsup,
		const std::vector< double > &	normalizedVsup,
		const std::vector< std::vector< unsigned int > > &	fullSecIDsBaseType )

inlineprivate

Adds the static sector: TODO: need documentation for the parameters.

Definition at line 603 of file VXDTFFilters.h.

    {
      std::vector< std::vector< FullSecID >> fullSecIDs;
 
      for (const auto& col : fullSecIDsBaseType) {
        std::vector< FullSecID > tmp_col;
        for (auto id : col)
          tmp_col.push_back(FullSecID(id));
        fullSecIDs.push_back(tmp_col);
      }
 
      return addSectorsOnSensor(normalizedUsup, normalizedVsup, fullSecIDs);
    }

◆ addThreeHitFilter()

template<class point_t>

int addThreeHitFilter	(	FullSecID	outer,
		FullSecID	center,
		FullSecID	inner,
		const threeHitFilter_t &	filter )

inline

adds a three hit filter

Definition at line 189 of file VXDTFFilters.h.

    {
 
      if (m_staticSectors.size() <= m_compactSecIDsMap[ outer ] ||
          m_compactSecIDsMap[ outer ] == 0 ||
          m_compactSecIDsMap[ center ] == 0 ||
          m_compactSecIDsMap[ inner ] == 0)
        return 0;
 
      m_staticSectors[m_compactSecIDsMap[outer]]->assign3spFilter(center,
                                                                  inner,
                                                                  filter);
      return 1;
    }

◆ addTwoHitFilter()

template<class point_t>

int addTwoHitFilter	(	FullSecID	outer,
		FullSecID	inner,
		const twoHitFilter_t &	filter )

inline

adds a two hit filter

Definition at line 175 of file VXDTFFilters.h.

    {
      if (m_staticSectors.size() <= m_compactSecIDsMap[ outer ] ||
          m_compactSecIDsMap[ outer ] == 0)
        return 0;
 
      m_staticSectors[m_compactSecIDsMap[outer]]->assign2spFilter(inner, filter);
      return 1;
    }

◆ areCoordinatesValid()

template<class point_t>

bool areCoordinatesValid	(	VxdID	aSensorID,
		double	normalizedU,
		double	normalizedV ) const

inline

check if using getFullID() would be safe (true if it is safe):

Definition at line 248 of file VXDTFFilters.h.

    {
      return m_compactSecIDsMap.areCoordinatesValid(aSensorID,
                                                    normalizedU, normalizedV);
    }

◆ getCompactID()

template<class point_t>

CompactSecIDs::sectorID_t getCompactID ( FullSecID outer ) const

inline

returns compactSecID for given FullSecID, == 0 if not found.

Definition at line 209 of file VXDTFFilters.h.

210 { return m_compactSecIDsMap[outer]; }

◆ getCompactIDsMap()

template<class point_t>

const CompactSecIDs & getCompactIDsMap ( ) const

inline

JKL: intended for some checks only - returns CompactIDsMap storing the static sectors.

Definition at line 282 of file VXDTFFilters.h.

282{ return m_compactSecIDsMap; }

◆ getConfig()

template<class point_t>

const SectorMapConfig & getConfig ( void ) const

inline

returns the configuration settings for this VXDTFFilters.

Definition at line 274 of file VXDTFFilters.h.

274{ return m_testConfig; }

◆ getFullID() [1/2]

template<class point_t>

FullSecID getFullID ( CompactSecIDs::sectorID_t compactSecID ) const

inline

returns the FullSecId of

Parameters

compactSecID

Definition at line 268 of file VXDTFFilters.h.

    {
      return m_staticSectors.at(compactSecID)->getFullSecID();
    }

◆ getFullID() [2/2]

template<class point_t>

FullSecID getFullID	(	VxdID	aSensorID,
		double	normalizedU,
		double	normalizedV ) const

inline

returns fullSecID for given sensorID and local coordinates.

Definition at line 259 of file VXDTFFilters.h.

    {
      // TODO WARNING how to catch bad cases?
      return m_compactSecIDsMap.getFullSecID(aSensorID, normalizedU, normalizedV);
    }

◆ getStaticSector()

template<class point_t>

const staticSector_t * getStaticSector ( const FullSecID secID ) const

inline

returns pointer to static sector for given fullSecID.

if fullSecID is not found, a nullptr is returned.

Parameters

secID FullSecID of the filter to be retrieved

Definition at line 220 of file VXDTFFilters.h.

    {
      auto sectorPosition = m_compactSecIDsMap[ secID ];
      if (sectorPosition == 0) return nullptr;
      return m_staticSectors[ sectorPosition ];
    }

◆ getStaticSectors()

template<class point_t>

const std::vector< staticSector_t * > & getStaticSectors ( ) const

inline

JKL: intended for some checks only - returns CompactIDsMap storing the static sectors.

Definition at line 286 of file VXDTFFilters.h.

286{ return m_staticSectors; }

◆ getTwoHitFilters()

template<class point_t>

const twoHitFilter_t getTwoHitFilters	(	const FullSecID &	outer,
		const FullSecID &	inner ) const

inline

retrieves a two hit filter:

Parameters

outer	FullSecID of the outer static sector this filter is attached to
inner	FullSecID of the inner static sector this filter is attached to

Definition at line 231 of file VXDTFFilters.h.

    {
      // TODO: sanity checks
      static twoHitFilter_t just_in_case;
      const auto* staticSector = m_staticSectors[ m_compactSecIDsMap[ outer ] ];
      // catch case when sector is not part of the sectorMap:
      if (staticSector == nullptr)
        return just_in_case;
      const auto* filterPtr = staticSector->getFilter2sp(inner);
      if (filterPtr == nullptr)
        return just_in_case;
      return *filterPtr;
    }

◆ lockFilters()

template<class point_t>

void lockFilters ( )

inline

This function should be called only AFTER all adjustments to the filters have been performed.

It sets m_preventModification to true and the VXDTFFilter is locked meaning that all function trying to modify it will be doing nothing. After a filter is locked it can NOT be unlocked.

Definition at line 354 of file VXDTFFilters.h.

354{ m_preventModification = true; };

◆ modify2SPFilters()

template<class point_t>

void modify2SPFilters ( const std::vector< std::tuple< int, std::string > > & adjustFunctions )

inline

modifies the 2SP-filters according to the functions given

Parameters

adjustFunctions a vector of vectors that contain exactly two strings, the first string will be interpreted integer, the second one will be interpreted TF1 regexp.

Definition at line 359 of file VXDTFFilters.h.

    {
 
      // locked filters cannot be modified
      if (m_preventModification) {
        B2FATAL("Trying to modify a locked filter! A locked filter is not supposed to be changed anymore!");
      }
 
      for (auto staticSector : m_staticSectors) {
        if (staticSector == nullptr) continue;
        staticSector->modify2SPFilters(adjustFunctions);
      }
    };

◆ modify3SPFilters()

template<class point_t>

void modify3SPFilters ( const std::vector< std::tuple< int, std::string > > & adjustFunctions )

inline

modifies the 3SP-filters according to the functions given

Parameters

adjustFunctions a vector of vectors that contain exactly two strings, the first string will be interpreted integer, the second one will be interpreted as regexp to generate a TF1.

Definition at line 376 of file VXDTFFilters.h.

    {
 
      // locked filters cannot be modified
      if (m_preventModification) {
        B2FATAL("Trying to modify a locked filter! A locked filter is not supposed to be changed anymore!");
      }
 
      for (auto staticSector : m_staticSectors) {
        if (staticSector == nullptr) continue;
        staticSector->modify3SPFilters(adjustFunctions);
      }
    };

◆ persistFilters()

template<class point_t>

bool persistFilters ( void ) const

inlineprivate

Persists on the current TDirectory the StaticSectors.

Definition at line 470 of file VXDTFFilters.h.

    {
 
      TTree* sp2tree = new TTree("SegmentFilters", "SegmentFilters");
      twoHitFilter_t twoHitFilter;
      twoHitFilter.persist(sp2tree, "filter");
 
      unsigned int outerFullSecID2sp, innerFullSecID2sp;
      sp2tree->Branch("outerFullSecID", & outerFullSecID2sp);
      sp2tree->Branch("innerFullSecID", & innerFullSecID2sp);
 
 
      TTree* sp3tree = new TTree("TripletsFilters", "TripletFilters");
      threeHitFilter_t threeHitFilter;
      threeHitFilter.persist(sp3tree, "filter");
 
      unsigned int outerFullSecID3sp, centerFullSecID3sp,
               innerFullSecID3sp;
      sp3tree->Branch("outerFullSecID", & outerFullSecID3sp);
      sp3tree->Branch("centerFullSecID", & centerFullSecID3sp);
      sp3tree->Branch("innerFullSecID", & innerFullSecID3sp);
 
      for (const auto* staticSector : m_staticSectors) {
        if (staticSector == nullptr)
          // Why there is an empty sector per layer?
          continue;
 
 
        outerFullSecID3sp = outerFullSecID2sp = staticSector->getFullSecID();
        auto segmentFilters = staticSector->getAllFilters2sp();
        for (auto compactIdFilterPair : segmentFilters) {
          auto innerCompactId = compactIdFilterPair.first;
          innerFullSecID2sp = getFullID(innerCompactId);
          twoHitFilter = compactIdFilterPair.second;
          sp2tree->Fill();
        }
 
        auto tripletFilters = staticSector->getAllFilters3sp();
        for (auto compactIdFilterPair : tripletFilters) {
          CompactSecIDs::sectorID_t id_center, id_inner;
          CompactSecIDs::extractCompactID(compactIdFilterPair.first, id_center, id_inner);
          centerFullSecID3sp = getFullID(id_center);
          innerFullSecID3sp = getFullID(id_inner);
          threeHitFilter = compactIdFilterPair.second;
          sp3tree->Fill();
        }
 
 
      }
 
      return true;
    }

◆ persistOnRootFile()

template<class point_t>

bool persistOnRootFile ( void ) const

inline

Persists (i.e.: writes) on the current TDirectory the whole object.

Definition at line 292 of file VXDTFFilters.h.

    {
 
      if (! m_testConfig.Write("config"))
        return false;
      // cppcheck-suppress knownConditionTrueFalse ; the persist/retrieve helpers currently always succeed, the check guards future implementations
      if (! persistSectors())
        return false;
 
      // cppcheck-suppress knownConditionTrueFalse ; the persist/retrieve helpers currently always succeed, the check guards future implementations
      if (! persistFilters())
        return false;
 
      return true;
    };

◆ persistSectors()

template<class point_t>

bool persistSectors ( void ) const

inlineprivate

Persists all the sectors on the current TDirectory.

Definition at line 393 of file VXDTFFilters.h.

    {
      TTree* tree = new TTree(c_CompactSecIDstreeName, c_CompactSecIDstreeName);
      UInt_t layer, ladder, sensor;
      tree->Branch("layer", & layer, "layer/i");
      tree->Branch("ladder", & ladder, "ladder/i");
      tree->Branch("sensor", & sensor, "sensor/i");
 
      std::vector< double >* normalizedUsup = new std::vector< double> ();
      tree->Branch("normalizedUsup", & normalizedUsup);
 
      std::vector< double >* normalizedVsup = new std::vector< double> ({1., 2., 3., 4.});
      tree->Branch("normalizedVsup", & normalizedVsup);
 
      std::vector< std::vector< unsigned int > >* fullSecIDs =
        new std::vector< std::vector< unsigned int > > ();
      tree->Branch("fullSecID", & fullSecIDs);
 
      unsigned nOfLayers = m_compactSecIDsMap.nOfLayers();
      for (layer = 0 ; layer < nOfLayers ; layer ++) {
        unsigned nOfLadders = m_compactSecIDsMap.nOfLadders(layer);
        for (ladder = 0; ladder < nOfLadders ; ladder ++) {
          unsigned nOfSensors = m_compactSecIDsMap.nOfSensors(layer, ladder);
          for (sensor = 0; sensor < nOfSensors ; sensor ++) {
            normalizedUsup->clear();
            normalizedVsup->clear();
            fullSecIDs->clear();
            auto sectorsOnSensor =
              m_compactSecIDsMap.getSectorsOnSensor(layer, ladder, sensor);
            sectorsOnSensor.get(normalizedUsup, normalizedVsup, fullSecIDs);
            tree->Fill();
          }
        }
      }
      delete normalizedVsup;
      delete normalizedUsup;
      delete fullSecIDs;
      return true;
    }

◆ retrieveFilters()

template<class point_t>

bool retrieveFilters ( const TString * dirName )

inlineprivate

Retrieves from the current TDirectory the StaticSectors.

Definition at line 524 of file VXDTFFilters.h.

    {
      TString sp2treeName = *dirName;
      sp2treeName.Append("/SegmentFilters");
      TTree* sp2tree = dynamic_cast<TTree*>(gFile->Get(sp2treeName));
      if (!sp2tree)
        return false;
 
      twoHitFilter_t twoHitFilter;
      twoHitFilter.setBranchAddress(sp2tree, "filter");
 
      unsigned int outerFullSecID2sp, innerFullSecID2sp;
      if (sp2tree->SetBranchAddress("outerFullSecID", & outerFullSecID2sp) < 0) B2FATAL("VXDTFFilters: invalid branch address");
      if (sp2tree->SetBranchAddress("innerFullSecID", & innerFullSecID2sp) < 0) B2FATAL("VXDTFFilters: invalid branch address");
 
      for (Long64_t i = 0 ; i < sp2tree->GetEntries() ; i++) {
        sp2tree->GetEntry(i);
 
        // cross check to only put filters into the map which outer sector is also on outer layer!
        FullSecID outer_secid_2sp(outerFullSecID2sp);
        FullSecID inner_secid_2sp(innerFullSecID2sp);
        // equal layer numbers are allowed!
        if (outer_secid_2sp.getLayerNumber() < inner_secid_2sp.getLayerNumber()) {
          B2WARNING("Outer sector is not on outer layer! Not adding this filter. \"Outer\" layer number: "
                    << outer_secid_2sp.getLayerNumber() << " \"Inner\" layer number " << inner_secid_2sp.getLayerNumber());
          continue;
        }
 
        // add filter to the map
        if (!addTwoHitFilter(outer_secid_2sp, inner_secid_2sp,
                             twoHitFilter))
          return false;
 
      }
 
      TString sp3treeName = *dirName;
      sp3treeName.Append("/TripletsFilters");
      TTree* sp3tree = dynamic_cast<TTree*>(gFile->Get(sp3treeName));
      if (! sp3tree)
        return false;
      threeHitFilter_t threeHitFilter;
      threeHitFilter.setBranchAddress(sp3tree, "filter");
 
      unsigned int outerFullSecID3sp, centerFullSecID3sp,
               innerFullSecID3sp;
      if (sp3tree->SetBranchAddress("outerFullSecID", & outerFullSecID3sp) < 0) B2FATAL("VXDTFFilters: invalid branch address");
      if (sp3tree->SetBranchAddress("centerFullSecID", & centerFullSecID3sp) < 0) B2FATAL("VXDTFFilters: invalid branch address");
      if (sp3tree->SetBranchAddress("innerFullSecID", & innerFullSecID3sp) < 0) B2FATAL("VXDTFFilters: invalid branch address");
 
      for (Long64_t i = 0 ; i < sp3tree->GetEntries() ; i++) {
        sp3tree->GetEntry(i);
 
        // cross check to only put filters which layers have correct order
        FullSecID outer_secid_3sp(outerFullSecID3sp);
        FullSecID center_secid_3sp(centerFullSecID3sp);
        FullSecID inner_secid_3sp(innerFullSecID3sp);
        // equal layer numbers are allowed
        if (outer_secid_3sp.getLayerNumber() < center_secid_3sp.getLayerNumber() or
            center_secid_3sp.getLayerNumber() < inner_secid_3sp.getLayerNumber()) {
          B2WARNING("Layers not in the correct order for Triplet filter! Will not add filter! Outer layer number: " <<
                    outer_secid_3sp.getLayerNumber() << " center layer number: " << center_secid_3sp.getLayerNumber() <<
                    " inner layer number: " << inner_secid_3sp.getLayerNumber());
          continue;
        }
 
        // add the filter to the map
        if (!addThreeHitFilter(outer_secid_3sp, center_secid_3sp,
                               inner_secid_3sp,
                               threeHitFilter))
          return false;
 
      }
 
      return true;
    }

◆ retrieveFromRootFile()

template<class point_t>

bool retrieveFromRootFile ( const TString * dirName )

inline

Retrieves from the current TDirectory all the VXDTFFilters.

Definition at line 309 of file VXDTFFilters.h.

    {
      // locked filters cannot be modified
      if (m_preventModification) {
        B2FATAL("Trying to modify a locked filter! A locked filter is not supposed to be changed anymore!");
      }
 
      if (! m_testConfig.Read("config"))
        return false;
 
      // cppcheck-suppress knownConditionTrueFalse ; the persist/retrieve helpers currently always succeed, the check guards future implementations
      if (! retrieveSectors(dirName))
        return false;
 
      if (! retrieveFilters(dirName))
        return false;
 
      return true;
    };

◆ retrieveSectors()

template<class point_t>

bool retrieveSectors ( const TString * dirName )

inlineprivate

Read the whole CompactSecIDs from the current TDirectory.

Definition at line 434 of file VXDTFFilters.h.

    {
      TString treeName = *dirName;
      treeName.Append("/");
      treeName.Append(c_CompactSecIDstreeName);
      TTree* tree = dynamic_cast<TTree*>(gFile->Get(treeName));
      UInt_t layer, ladder, sensor;
      if (tree->SetBranchAddress("layer", & layer) < 0) B2FATAL("VXDTFFilters: invalid branch address");
      if (tree->SetBranchAddress("ladder", & ladder) < 0) B2FATAL("VXDTFFilters: invalid branch address");
      if (tree->SetBranchAddress("sensor", & sensor) < 0) B2FATAL("VXDTFFilters: invalid branch address");
 
      std::vector< double >* normalizedUsup = new std::vector< double> ();
      if (tree->SetBranchAddress("normalizedUsup", & normalizedUsup) < 0) B2FATAL("VXDTFFilters: invalid branch address");
 
      std::vector< double >* normalizedVsup = new std::vector< double> ({1., 2., 3., 4.});
      if (tree->SetBranchAddress("normalizedVsup", & normalizedVsup) < 0) B2FATAL("VXDTFFilters: invalid branch address");
 
      std::vector< std::vector< unsigned int > >* fullSecIDs =
        new std::vector< std::vector< unsigned int > > ();
      if (tree->SetBranchAddress("fullSecID", & fullSecIDs) < 0) B2FATAL("VXDTFFilters: invalid branch address");
 
 
      for (Long64_t i = 0; i < tree->GetEntries() ; i++) {
        tree->GetEntry(i);
        this->addSectorsOnSensor(* normalizedUsup,
                                 * normalizedVsup,
                                 * fullSecIDs);
      }
 
      delete normalizedVsup;
      delete normalizedUsup;
      delete fullSecIDs;
      return true;
    }

◆ setConfig()

template<class point_t>

void setConfig ( const SectorMapConfig & config )

inline

set the configuration which is used to create this filter

Parameters

config the new configuration

Definition at line 278 of file VXDTFFilters.h.

278{ m_testConfig = config; }

◆ setSubLayerIDs()

template<class point_t>

bool setSubLayerIDs	(	FullSecID	sector,
		int	sublayer )

inline

during the trainings phase the sublayer ids have to be updated

Parameters

sector	: FullSecID of the sector to be updated (SubLayerID of sector will be ignored while searching for it!)
sublayer	: new value for the sublayer, the new SubLayerID will be 0 if sublayer==0, and 1 else

Definition at line 332 of file VXDTFFilters.h.

    {
      // locked filters cannot be modified
      if (m_preventModification) {
        B2FATAL("Trying to modify a locked filter! A locked filter is not supposed to be changed anymore!");
      }
 
      // first update the static sector
      // the static sector is retrieved from the compactid which automatically ignores the sublayer id
      auto sectorPosition = m_compactSecIDsMap[ sector ];
      if (sectorPosition == 0) return false;
      staticSector_t* staticsector = m_staticSectors[ sectorPosition ];
      if (!staticsector) return false;
      staticsector->setSubLayerID(sublayer);
 
      // then update the fullsectorid in the compactsectoridmap, the sublayerid of sector will be ignored when searching for sector to update
      return m_compactSecIDsMap.setSubLayerID(sector, sublayer);
    }

◆ size()

template<class point_t>

unsigned size ( ) const

inline

returns number of compact secIDs stored for this filter-container.

Definition at line 289 of file VXDTFFilters.h.

289{ return m_compactSecIDsMap.getSize(); }

Member Data Documentation

◆ c_CompactSecIDstreeName

template<class point_t>

const char* c_CompactSecIDstreeName = "CompactSecIDs"

private

name of the tree the SecIDs are stored in when persisted

Definition at line 637 of file VXDTFFilters.h.

◆ m_compactSecIDsMap

template<class point_t>

CompactSecIDs m_compactSecIDsMap

private

This member takes care of converting the [layer][ladder] [sensor][sector] multi index into a linear index on the m_staticSectors vector.

Definition at line 625 of file VXDTFFilters.h.

◆ m_preventModification

template<class point_t>

bool m_preventModification = false

private

The filters are not supposed to be altered after initialization (typically in the Module::initialize() function).

To prevent accidental alteration of the contained filters one can set this parameter to true which will not allow further modification of the stored filters. A check of this variable should be included in every public function that modifies filters!

Definition at line 643 of file VXDTFFilters.h.

◆ m_staticSectors

template<class point_t>

std::vector< staticSector_t* > m_staticSectors

private

This vector contains all the static sectors on a sector map.

The index is the compact ID provided by the CompactSecIDs

Definition at line 630 of file VXDTFFilters.h.

◆ m_testConfig

template<class point_t>

SectorMapConfig m_testConfig

private

Configuration: i.e.

name of the sector map, tuning parameters, etc.

Definition at line 634 of file VXDTFFilters.h.

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

tracking/trackFindingVXD/environment/include/VXDTFFilters.h

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ staticSector_t

◆ threeHitFilter_t

◆ twoHitFilter_t

Constructor & Destructor Documentation

◆ VXDTFFilters()

◆ ~VXDTFFilters()

Member Function Documentation

◆ addSectorsOnSensor() [1/2]

◆ addSectorsOnSensor() [2/2]

◆ addThreeHitFilter()

◆ addTwoHitFilter()

◆ areCoordinatesValid()

◆ getCompactID()

◆ getCompactIDsMap()

◆ getConfig()

◆ getFullID() [1/2]

◆ getFullID() [2/2]

◆ getStaticSector()

◆ getStaticSectors()

◆ getTwoHitFilters()

◆ lockFilters()

◆ modify2SPFilters()

◆ modify3SPFilters()

◆ persistFilters()

◆ persistOnRootFile()

◆ persistSectors()

◆ retrieveFilters()

◆ retrieveFromRootFile()

◆ retrieveSectors()

◆ setConfig()

◆ setSubLayerIDs()

◆ size()

Member Data Documentation

◆ c_CompactSecIDstreeName

◆ m_compactSecIDsMap

◆ m_preventModification

◆ m_staticSectors

◆ m_testConfig