SecMapTrainer< FilterFactoryType > Class Template Reference

This class contains all relevant tools for training a VXDTFFilters. More...

#include <SecMapTrainer.h>

Public Member Functions
	SecMapTrainer (const std::string &setupName, const std::string &appendix="")
	constructor.
void	initialize ()
	initialize the trainer (to be called in Module::initialize().
void	terminate ()
	initialize the trainer (to be called in Module::terminate().
void	initializeEvent (int expNo, int runNo, int evtNo)
	Initialize event.
const SectorMapConfig &	getConfig ()
	returns configuration.
const std::string	getSetupName ()
	returns the name of the setup used for this trainer
bool	storeTC (const SpacePointTrackCand &tc, unsigned iD)
	checks if given TC is acceptable for this trainer and store it if it is accepted.
unsigned	processTracks ()
	for given normalized local variables and VxdID a FullSecID is determined.

Protected Member Functions
bool	acceptHit (const SpacePoint &hit)
	checks if given Hit is acceptable for this trainer.
unsigned	process2HitCombinations (const SecMapTrainerTC &aTC)
	processes all two-hit-combinations of given TC and stores their results.
unsigned	process3HitCombinations (const SecMapTrainerTC &aTC)
	processes all three-hit-combinations of given TC and stores their results.
void	convertSP2TC (const std::vector< std::pair< FullSecID, const SpacePoint * > > &goodSPs, unsigned tcID, double pTValue, int pdgCode)
	converts the SpacePoints into a SecMapTrainerTC and stores it to m_TCs

Protected Attributes
const std::string	m_nameSetup
	name of the setting to be used for this training
FiltersContainer< SpacePoint > &	m_filtersContainer = Belle2::FiltersContainer<SpacePoint>::getInstance()
	a reference to the singleton FiltersContainer used for this training.
SectorMapConfig	m_config
	Contains all relevant configurations needed for training a sectorMap.
FilterFactoryType	m_factory
	A factory taking care of having the correct filters prepared for secMapTraining.
FilterMill< SecMapTrainerHit >	m_filterMill
	Stores the prepared filters and applies them on given hit-combinations.
RawSecMapRootInterface	m_rootInterface
	Interface for nice and neat storing in root-ttree.
std::vector< SecMapTrainerTC >	m_tcs
	contains tcs of event, reset after each event.
unsigned	m_expNo
	contains current experiment number.
unsigned	m_runNo
	contains current run number.
unsigned	m_evtNo
	contains current event number.

Detailed Description

template<class FilterFactoryType>
class Belle2::SecMapTrainer< FilterFactoryType >

This class contains all relevant tools for training a VXDTFFilters.

Definition at line 43 of file SecMapTrainer.h.

Constructor & Destructor Documentation

SecMapTrainer()

SecMapTrainer ( const std::string &  setupName, const std::string &  appendix = ""  )

inlineexplicit

constructor.

Definition at line 235 of file SecMapTrainer.h.

                                                                                       :
      m_nameSetup(setupName),
      m_config(m_filtersContainer.getFilters(m_nameSetup)->getConfig()),
      m_factory(
        m_config.vIP.X(),
        m_config.vIP.Y(),
        m_config.vIP.Z(),
        m_config.mField),
 
      m_filterMill(),
      m_rootInterface(m_config.secMapName, appendix),
      m_expNo(std::numeric_limits<unsigned>::max()),
      m_runNo(std::numeric_limits<unsigned>::max()),
      m_evtNo(std::numeric_limits<unsigned>::max())
    {
      // stretch the cuts:
//       m_config.pTCuts.first -= m_config.pTCuts.first * m_config.pTSmear;
//       m_config.pTCuts.second += m_config.pTCuts.second * m_config.pTSmear;
      m_config.pTmin -= m_config.pTmin * m_config.pTSmear;
      m_config.pTmax += m_config.pTmax * m_config.pTSmear;
    }

Member Function Documentation

acceptHit()

bool acceptHit ( const SpacePoint &  hit )

inlineprotected

checks if given Hit is acceptable for this trainer.

Returns true if accepted and false otherwise.

Definition at line 87 of file SecMapTrainer.h.

    {
      // rejects if layerID is not acceptable for this secMap-training.
      auto layerID = hit.getVxdID().getLayerNumber();
      bool found = false;
      std::string ids = "";
      for (auto allowedLayer : m_config.allowedLayers) {
        ids += std::to_string(allowedLayer) + " ";
        if (allowedLayer == layerID) found = true;
      }
      B2DEBUG(20, "SecMapTrainer::acceptHit: the TC has layerID: " << layerID << " and allowd layers: " << ids << " and was " <<
              (found ? "accepted" : "rejected"));
 
      return found;
    }

convertSP2TC()

void convertSP2TC ( const std::vector< std::pair< FullSecID, const SpacePoint * > > &  goodSPs, unsigned  tcID, double  pTValue, int  pdgCode  )

inlineprotected

converts the SpacePoints into a SecMapTrainerTC and stores it to m_TCs

Definition at line 208 of file SecMapTrainer.h.

    {
      B2DEBUG(20, "SecMapTrainer::convertSPTC: nGoodHits: " << goodSPs.size());
 
      SecMapTrainerTC newTrack(tcID, pTValue, pdgCode);
 
      for (const auto& secIDAndSPpair : goodSPs) {
        FullSecID fullSecID = secIDAndSPpair.first;
        B2DEBUG(20, "SecMapTrainer::convertSPTC: found fullSecID: " << fullSecID.getFullSecString());
 
        newTrack.addHit(SecMapTrainerHit(fullSecID,  *secIDAndSPpair.second));
      }
 
      // add vertex (but without real vertexPosition, since origin is assumed)
      SecMapTrainerHit newVirtualHit(FullSecID(), m_config.vIP);
 
      newTrack.addHit(std::move(newVirtualHit));
 
      m_tcs.push_back(std::move(newTrack));
    }

getConfig()

const SectorMapConfig & getConfig ( )

inline

returns configuration.

Definition at line 323 of file SecMapTrainer.h.

{ return m_config; }

getSetupName()

const std::string getSetupName ( )

inline

returns the name of the setup used for this trainer

Definition at line 327 of file SecMapTrainer.h.

{ return m_nameSetup; }

initialize()

void initialize ( )

inline

initialize the trainer (to be called in Module::initialize().

Definition at line 259 of file SecMapTrainer.h.

    {
      // prepare the filters!
      // 2 space points:
      auto TwoSPfilterNamesToFunctions(SelectionVariableNamesToFunctions(VXDTFFilters<SecMapTrainerHit>::twoHitFilter_t()));
 
      std::vector< std::string> twoHitFilters;
      for (const auto& filterNameToFunction : TwoSPfilterNamesToFunctions)
        twoHitFilters.push_back(filterNameToFunction.first);
 
      m_rootInterface.initialize2Hit(twoHitFilters);
      for (auto& nameToFunction : TwoSPfilterNamesToFunctions)
        m_filterMill.add2HitFilter(nameToFunction);
 
 
      // 3 space points:
      auto ThreeSPfilterNamesToFunctions(SelectionVariableNamesToFunctions(
                                           VXDTFFilters<SecMapTrainerHit>::threeHitFilter_t()));
 
      std::vector< std::string> threeHitFilters;
      for (const auto& filterNameToFunction : ThreeSPfilterNamesToFunctions)
        threeHitFilters.push_back(filterNameToFunction.first);
 
      m_rootInterface.initialize3Hit(threeHitFilters);
      for (auto& nameToFunction : ThreeSPfilterNamesToFunctions)
        m_filterMill.add3HitFilter(nameToFunction);
      for (auto& nameToFunction : ThreeSPfilterNamesToFunctions)
        m_filterMill.add3HitFilter(nameToFunction);
 
 
      // 4 space points apparently unused
      // m_rootInterface.initialize4Hit(m_config.fourHitFilters);
 
      // auto FourSPfilterNamesToFunctions( SelectionVariableNamesToFunctions(
      //                     VXDTFFilters<SecMapTrainerHit>::fourHitFilter_t() ));
 
      // std::vector< std::string> fourHitFilters;
      // for (const auto& filterNameToFunction :FourSPfilterNamesToFunctions )
      //  fourHitFilters.push_back( filterNameToFunction.first );
 
      // m_rootInterface.initialize4Hit(fourHitFilters);
      // for (auto& nameToFunction : FourSPfilterNamesToFunctions)
      //  m_filterMill.add4HitFilter(nameToFunction);
 
      // prevent further modifications:
      m_filterMill.lockMill();
    }

initializeEvent()

void initializeEvent ( int  expNo, int  runNo, int  evtNo  )

inline

Initialize event.

Definition at line 314 of file SecMapTrainer.h.

    {
      m_expNo = expNo;
      m_runNo = runNo;
      m_evtNo = evtNo;
    }

process2HitCombinations()

unsigned process2HitCombinations ( const SecMapTrainerTC &  aTC )

inlineprotected

processes all two-hit-combinations of given TC and stores their results.

returns number of stored values.

Definition at line 106 of file SecMapTrainer.h.

    {
      unsigned nValues = 0;
      B2DEBUG(20, "SecMapTrainer::process2HitCombinations: nHits/trackID/pdg: " << aTC.size() << "/" << aTC.getTrackID() << "/" <<
              aTC.getPDG());
      if (aTC.size() < 2) { return nValues; }
 
      // the iterators mark the hits to be used:
      SecMapTrainerTC::ConstIterator outerIt = aTC.outermostHit();
      SecMapTrainerTC::ConstIterator innerIt = ++aTC.outermostHit();
 
      // loop over all 2-hit-combis, collect data for each filterType and store it in root-tree:
      std::vector<std::pair<std::string, double> > collectedResults;
      for (; innerIt != aTC.innerEnd();) {
        B2DEBUG(20, "SecMapTrainer::process2HitCombinations: outerHit-/innerHitSecID: " << outerIt->getSectorIDString() <<
                "/" << innerIt->getSectorIDString());
 
        auto& dataSet = m_rootInterface.get2HitDataSet();
        dataSet.expNo = m_expNo;
        dataSet.runNo = m_runNo;
        dataSet.evtNo = m_evtNo;
        dataSet.trackNo = aTC.getTrackID();
        dataSet.pdg = aTC.getPDG();
        dataSet.secIDs.outer = outerIt->getSectorID().getFullSecID();
        dataSet.secIDs.inner = innerIt->getSectorID().getFullSecID();
 
        // create data for each filterType:
        FilterMill<SecMapTrainerHit>::HitPair newHitPair;
        newHitPair.outer = &(*outerIt);
        newHitPair.inner = &(*innerIt);
        m_filterMill.grindData2Hit(newHitPair, collectedResults);
 
        // fill data for each filter type:
        for (const auto& entry : collectedResults) {
          B2DEBUG(25, "SecMapTrainer::process2HitCombinations: filter/value: " << entry.first << "/" << entry.second);
          dataSet.setValueOfFilter(entry.first, entry.second);
          ++nValues;
        }
        m_rootInterface.fill2Hit();
        collectedResults.clear();
        ++outerIt;
        ++innerIt;
      }
      return nValues;
    }

process3HitCombinations()

unsigned process3HitCombinations ( const SecMapTrainerTC &  aTC )

inlineprotected

processes all three-hit-combinations of given TC and stores their results.

returns number of stored values.

Definition at line 155 of file SecMapTrainer.h.

    {
      unsigned nValues = 0;
      B2DEBUG(20, "SecMapTrainer::process3HitCombinations: nHits/trackID/pdg: " << aTC.size() << "/" << aTC.getTrackID() << "/" <<
              aTC.getPDG());
      if (aTC.size() < 3) { return nValues; }
 
      // the iterators mark the hits to be used:
      SecMapTrainerTC::ConstIterator outerIt = aTC.outermostHit();
      SecMapTrainerTC::ConstIterator centerIt = ++aTC.outermostHit();
      SecMapTrainerTC::ConstIterator innerIt = ++(++aTC.outermostHit());
 
      // loop over all 3-hit-combis, collect data for each filterType and store it in root-tree:
      std::vector<std::pair<std::string, double> > collectedResults;
      for (; innerIt != aTC.innerEnd();) {
        B2DEBUG(20, "SecMapTrainer::process3HitCombinations: outer-/center-/innerHitSecID: " << outerIt->getSectorIDString() <<
                "/" << centerIt->getSectorIDString() <<
                "/" << innerIt->getSectorIDString());
 
        auto& dataSet = m_rootInterface.get3HitDataSet();
        dataSet.expNo = m_expNo;
        dataSet.runNo = m_runNo;
        dataSet.evtNo = m_evtNo;
        dataSet.trackNo = aTC.getTrackID();
        dataSet.pdg = aTC.getPDG();
        dataSet.secIDs.outer = outerIt->getSectorID().getFullSecID();
        dataSet.secIDs.center = centerIt->getSectorID().getFullSecID();
        dataSet.secIDs.inner = innerIt->getSectorID().getFullSecID();
 
        // create data for each filterType:
        FilterMill<SecMapTrainerHit>::HitTriplet newHitTriplet;
        newHitTriplet.outer = &(*outerIt);
        newHitTriplet.center = &(*centerIt);
        newHitTriplet.inner = &(*innerIt);
        m_filterMill.grindData3Hit(newHitTriplet, collectedResults);
 
        // fill data for each filter type:
        for (const auto& entry : collectedResults) {
          B2DEBUG(25, "SecMapTrainer::process3HitCombinations: filter/value: " << entry.first << "/" << entry.second);
          dataSet.setValueOfFilter(entry.first, entry.second);
          ++nValues;
        }
        m_rootInterface.fill3Hit();
        collectedResults.clear();
        ++outerIt;
        ++centerIt;
        ++innerIt;
      }
      return nValues;
    }

processTracks()

unsigned processTracks ( )

inline

for given normalized local variables and VxdID a FullSecID is determined.

returns unsigned int max if correct ID could not be found. takes all TCs stored and processed them for root storing. Takes care of cleaning event-dependent TCs.

Definition at line 426 of file SecMapTrainer.h.

    {
      unsigned n2HitResults = 0;
      unsigned n3HitResults = 0;
      unsigned nTracksProcessed = m_tcs.size();
 
      for (const auto& tc : m_tcs) {
        // two hit:
        n2HitResults += process2HitCombinations(tc);
        // three hit:
        n3HitResults += process3HitCombinations(tc);
      }
 
      m_tcs.clear();
      B2DEBUG(25, "SecMapTrainer::processTracks: nStoredValues for 2-/3-hit: " << n2HitResults << "/" << n3HitResults);
 
      return nTracksProcessed;
    }

storeTC()

bool storeTC ( const SpacePointTrackCand &  tc, unsigned  iD  )

inline

checks if given TC is acceptable for this trainer and store it if it is accepted.

The return value is true, it was accepted and stored, false if not.

Definition at line 333 of file SecMapTrainer.h.

    {
      B2DEBUG(20, "SecMapTrainer::storeTC: nHits/threshold: " << tc.getNHits() << "/" << m_config.nHitsMin);
      // catch TCS which are too short in any case
      if (tc.getNHits() < m_config.nHitsMin) return false;
 
      B2DEBUG(20, "SecMapTrainer::storeTC: hasHitsOnSameSensor: " << tc.hasHitsOnSameSensor());
      // catch TCs where more than one hit was on the same sensor
      if (tc.hasHitsOnSameSensor()) return false;
 
      // catch TCS where particle type is wrong
      bool found = false;
      for (const auto& pdg : m_config.pdgCodesAllowed) {
        if (tc.getPdgCode() == pdg) found = true;
      }
      if (found == false and m_config.pdgCodesAllowed.empty() == false) return false;
 
      // check if momentum of TC is within range:
      auto pT = tc.getMomSeed().Rho();
      B2DEBUG(20, "SecMapTrainer::storeTC: pT/thresholdmin/-max: " << pT << "/" << m_config.pTmin << "/" <<
              m_config.pTmax);
      if (m_config.pTmin > pT or m_config.pTmax < pT) return false;
 
      // catch tracks which start too far away from orign
      B2Vector3D distance2IP = m_config.vIP - tc.getPosSeed();
      B2DEBUG(20, "SecMapTrainer::storeTC: distance2IP/thresholdXY/-Z: " << distance2IP.Mag() << "/" << m_config.seedMaxDist2IPXY << "/"
              << m_config.seedMaxDist2IPZ);
      if (m_config.seedMaxDist2IPXY > 0
          and m_config.seedMaxDist2IPXY < distance2IP.Perp()) return false;
      if (m_config.seedMaxDist2IPZ > 0
          and m_config.seedMaxDist2IPXY < distance2IP.Z()) return false;
 
      // collect hits which fullfill all given tests
      std::vector<std::pair<FullSecID, const SpacePoint*> > goodSPs;
      for (const SpacePoint* aSP : tc.getHits()) {
        if (!acceptHit(*aSP)) continue;
 
        FullSecID fSecID = m_filtersContainer.getFilters(m_nameSetup)->getFullID(aSP->getVxdID(),
                           aSP->getNormalizedLocalU(), aSP->getNormalizedLocalV());
        if (fSecID.getFullSecID() == std::numeric_limits<unsigned int>::max())
        { B2ERROR("a secID for spacePoint not found!"); continue; }
 
        goodSPs.push_back({fSecID, aSP});
      }
 
      // catch tracks which have not enough accepted hits.
      B2DEBUG(20, "SecMapTrainer::storeTC: the TC has now nHits/threshold: " << goodSPs.size() << "/" << m_config.nHitsMin);
      if (goodSPs.size() < m_config.nHitsMin || goodSPs.size() == 0) return false;
 
      // want to have hits going from outer to inner ones
      if (tc.isOutgoing()) std::reverse(goodSPs.begin(), goodSPs.end());
 
 
      // enfoce a direction in the layer numbering, because else this could generate loops in the sectormap
      int prevLayerNum = goodSPs.at(0).second->getVxdID().getLayerNumber();
      for (auto& spCand : goodSPs) {
        int thisLayerNum = spCand.second->getVxdID().getLayerNumber();
        // allow same layer
        if (thisLayerNum > prevLayerNum) {
          B2DEBUG(20, "Rejected TC due to layer ordering of SPs! previous layer: " << prevLayerNum << " this layer: " << thisLayerNum);
          return false;
        }
        prevLayerNum = thisLayerNum;
      }
 
 
      convertSP2TC(goodSPs, iD, tc.getMomSeed().Rho(), tc.getPdgCode());
 
      return true;
    }

terminate()

void terminate ( )

inline

initialize the trainer (to be called in Module::terminate().

Definition at line 310 of file SecMapTrainer.h.

    { m_rootInterface.write(); }

Member Data Documentation

m_config

SectorMapConfig m_config

protected

Contains all relevant configurations needed for training a sectorMap.

Copy of the config in the SectorMap needed as it is modified (the one in VXDTFFilters is const).

Definition at line 54 of file SecMapTrainer.h.

m_evtNo

unsigned m_evtNo

protected

contains current event number.

Definition at line 80 of file SecMapTrainer.h.

m_expNo

unsigned m_expNo

protected

contains current experiment number.

Definition at line 72 of file SecMapTrainer.h.

m_factory

FilterFactoryType m_factory

protected

A factory taking care of having the correct filters prepared for secMapTraining.

Definition at line 57 of file SecMapTrainer.h.

m_filterMill

FilterMill<SecMapTrainerHit> m_filterMill

protected

Stores the prepared filters and applies them on given hit-combinations.

Definition at line 60 of file SecMapTrainer.h.

m_filtersContainer

FiltersContainer<SpacePoint>& m_filtersContainer = Belle2::FiltersContainer<SpacePoint>::getInstance()

protected

a reference to the singleton FiltersContainer used for this training.

Needed as some information are only accessable from the filters (in the container).

Definition at line 50 of file SecMapTrainer.h.

m_nameSetup

const std::string m_nameSetup

protected

name of the setting to be used for this training

Definition at line 46 of file SecMapTrainer.h.

m_rootInterface

RawSecMapRootInterface m_rootInterface

protected

Interface for nice and neat storing in root-ttree.

Definition at line 64 of file SecMapTrainer.h.

m_runNo

unsigned m_runNo

protected

contains current run number.

Definition at line 76 of file SecMapTrainer.h.

m_tcs

std::vector<SecMapTrainerTC> m_tcs

protected

contains tcs of event, reset after each event.

Definition at line 68 of file SecMapTrainer.h.

---

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

• tracking/trackFindingVXD/sectorMapTools/include/SecMapTrainer.h