VXDTFFilters< point_t > Class Template Reference

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

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

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

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()

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()

~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]

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 (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]

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 600 of file VXDTFFilters.h.

    {
      std::vector< std::vector< FullSecID >> fullSecIDs;
 
      for (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()

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()

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()

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()

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.

    { return m_compactSecIDsMap[outer]; }

getCompactIDsMap()

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.

{ return m_compactSecIDsMap; }

getConfig()

const SectorMapConfig & getConfig ( void  ) const

inline

returns the configuration settings for this VXDTFFilters.

Definition at line 274 of file VXDTFFilters.h.

{ return m_testConfig; }

getFullID() [1/2]

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]

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()

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()

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.

{ return m_staticSectors; }

getTwoHitFilters()

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()

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 351 of file VXDTFFilters.h.

{ m_preventModification = true; };

modify2SPFilters()

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 356 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()

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 373 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()

bool persistFilters ( void  ) const

inlineprivate

Persists on the current TDirectory the StaticSectors.

Definition at line 467 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 (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()

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;
      if (! persistSectors())
        return false;
 
      if (! persistFilters())
        return false;
 
      return true;
    };

persistSectors()

bool persistSectors ( void  ) const

inlineprivate

Persists all the sectors on the current TDirectory.

Definition at line 390 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()

bool retrieveFilters ( const TString *  dirName )

inlineprivate

Retrieves from the current TDirectory the StaticSectors.

Definition at line 521 of file VXDTFFilters.h.

    {
      TString sp2treeName = *dirName;
      sp2treeName.Append("/SegmentFilters");
      TTree* sp2tree = (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 = (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()

bool retrieveFromRootFile ( const TString *  dirName )

inline

Retrieves from the current TDirectory all the VXDTFFilters.

Definition at line 307 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;
 
      if (! retrieveSectors(dirName))
        return false;
 
      if (! retrieveFilters(dirName))
        return false;
 
      return true;
    };

retrieveSectors()

bool retrieveSectors ( const TString *  dirName )

inlineprivate

Read the whole CompactSecIDs from the current TDirectory.

Definition at line 431 of file VXDTFFilters.h.

    {
      TString treeName = *dirName;
      treeName.Append("/");
      treeName.Append(c_CompactSecIDstreeName);
      TTree* tree = (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()

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.

{ m_testConfig = config; }

setSubLayerIDs()

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 329 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()

unsigned size ( ) const

inline

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

Definition at line 289 of file VXDTFFilters.h.

{ return m_compactSecIDsMap.getSize(); }

Member Data Documentation

c_CompactSecIDstreeName

const char* c_CompactSecIDstreeName = "CompactSecIDs"

private

name of the tree the SecIDs are stored in when persisted

Definition at line 634 of file VXDTFFilters.h.

m_compactSecIDsMap

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 622 of file VXDTFFilters.h.

m_preventModification

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 640 of file VXDTFFilters.h.

m_staticSectors

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 627 of file VXDTFFilters.h.

m_testConfig

SectorMapConfig m_testConfig

private

Configuration: i.e.

name of the sector map, tuning parameters, etc.

Definition at line 631 of file VXDTFFilters.h.

---

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

• tracking/trackFindingVXD/environment/include/VXDTFFilters.h