HitBasedT0Extractor Class Reference

Findlet to extract the T0 time of an event only using CDC Hits. More...

#include <HitBasedT0Extractor.h>

Inheritance diagram for HitBasedT0Extractor:

Public Types
using	IOTypes = std::tuple< AIOTypes... >
	Types that should be served to apply on invocation.
using	IOVectors = std::tuple< std::vector< AIOTypes >... >
	Vector types that should be served to apply on invocation.

Public Member Functions
	HitBasedT0Extractor ()=default
	Constructor registering the subordinary findlets to the processing signal distribution machinery.
virtual	~HitBasedT0Extractor ()=default
	Make destructor of interface virtual.
std::string	getDescription () override final
	Short description of the findlet.
void	exposeParameters (ModuleParamList *moduleParamList, const std::string &prefix) override final
	Expose the parameters to a module.
void	apply (std::vector< TrackFindingCDC::CDCWireHit > &inputWireHits) override final
	Collects all Wire Hits and executes the t0 fit.
void	initialize () override final
	Initialize the event meta data.
bool	wasSuccessful () const
	Returns true if the last run t0 extraction was successful.
virtual void	beginEvent () override
	Create the event t0 store obj ptr.
virtual void	apply (ToVector< AIOTypes > &... ioVectors)=0
	Main function executing the algorithm.
void	beginRun () override
	Receive and dispatch signal for the beginning of a new run.
void	endRun () override
	Receive and dispatch signal for the end of the run.
void	terminate () override
	Receive and dispatch Signal for termination of the event processing.

Protected Types
using	ToVector = typename ToVectorImpl< T >::Type
	Short hand for ToRangeImpl.

Protected Member Functions
void	resetEventT0 () const
	Reset the t0 value to cached value if it exists or clear it otherwise.
void	addProcessingSignalListener (ProcessingSignalListener *psl)
	Register a processing signal listener to be notified.
int	getNProcessingSignalListener ()
	Get the number of currently registered listeners.

Protected Attributes
StoreObjPtr< EventT0 >	m_eventT0
	Pointer to the storage of the eventwise T0 estimation in the data store.
bool	m_wasSuccessful
	Variable to show that the execution was successful.

Private Types
using	Super = BaseEventTimeExtractor< TrackFindingCDC::CDCWireHit & >
	Type of the base class.

Private Attributes
unsigned int	m_param_minHitCount = 20
	minimum number of hits
float	m_param_searchWindow = 70.0f
	the window (+-m_param_searchWindow) in ns where to search for the best t0
float	m_param_fitWindow = 100.0f
	the space (+-m_param_fitWindow) in ns used to fit the t0
int	m_param_binCountTimeHistogram = 50
	number of bins in the timing histogram
bool	m_param_rejectByBackgroundFlag = false
	don't use hits for the fit which have been flagged as background
bool	m_param_rejectIfNotTakenFlag = true
	don't use hits for the fit which have not been assigned to any track
bool	m_param_storeAllFits = false
	store an image of the histogram and fit result, for debug purpose only
float	m_param_rejectIfChiSquareLargerThan = std::numeric_limits<float>::max()
	largest allowable chi2 value
float	m_param_rejectIfUncertaintyLargerThan = 12.0f
	largest allowable uncertainty value
float	m_param_refitWindow = 50.0f
	the width of the window in ns (+- m_param_refitWindow) used to refit the final t0 value
StoreObjPtr< EventMetaData >	m_eventMetaData
	access to event nr for debugging purposes
bool	m_param_overwriteExistingEstimation
	Parameter if it is fine to overwrite the current EventT0.
std::optional< EventT0::EventT0Component >	m_eventT0Before
	Storage for the event t0 before this module ran.
std::vector< ProcessingSignalListener * >	m_subordinaryProcessingSignalListeners
	References to subordinary signal processing listener contained in this findlet.
bool	m_initialized = false
	Flag to keep track whether initialization happened before.
bool	m_terminated = false
	Flag to keep track whether termination happened before.
std::string	m_initializedAs
	Name of the type during initialisation.

Detailed Description

Findlet to extract the T0 time of an event only using CDC Hits.

Definition at line 27 of file HitBasedT0Extractor.h.

Member Typedef Documentation

IOTypes

using IOTypes = std::tuple<AIOTypes...>

inherited

Types that should be served to apply on invocation.

Definition at line 30 of file Findlet.h.

IOVectors

using IOVectors = std::tuple< std::vector<AIOTypes>... >

inherited

Vector types that should be served to apply on invocation.

Definition at line 53 of file Findlet.h.

Super

using Super = BaseEventTimeExtractor<TrackFindingCDC::CDCWireHit&>

private

Type of the base class.

Definition at line 31 of file HitBasedT0Extractor.h.

ToVector

using ToVector = typename ToVectorImpl<T>::Type

protectedinherited

Short hand for ToRangeImpl.

Definition at line 49 of file Findlet.h.

Member Function Documentation

addProcessingSignalListener()

void addProcessingSignalListener ( ProcessingSignalListener *  psl )

protectedinherited

Register a processing signal listener to be notified.

Definition at line 55 of file CompositeProcessingSignalListener.cc.

{
  m_subordinaryProcessingSignalListeners.push_back(psl);
}

apply()

void apply ( std::vector< TrackFindingCDC::CDCWireHit > &  inputWireHits )

finaloverride

Collects all Wire Hits and executes the t0 fit.

Definition at line 98 of file HitBasedT0Extractor.cc.

{
  const auto timeHistogramName = "HitBasedT0Extractor_time_hist";
  const std::string debugImageName = "HitBasedT0Extractor_debug_" + boost::lexical_cast<std::string>
                                     (m_eventMetaData->getEvent()) + ".png";
 
  auto timingHistgram = TH1D(timeHistogramName, timeHistogramName,
                             m_param_binCountTimeHistogram, -m_param_fitWindow,
                             m_param_fitWindow);
 
  // Enable batch mode - we do not want to show the canvas etc.
  auto batchGuard = ScopeGuard::guardBatchMode();
 
  TCanvas canvas(debugImageName.c_str(), debugImageName.c_str(), 800, 600);
 
  if (inputWireHits.size() == 0) {
    B2WARNING("No input CDC hits available for the CDC hit based t0 extraction.");
    return;
  }
 
  for (auto const& wireHit : inputWireHits) {
 
    if (m_param_rejectByBackgroundFlag
        && wireHit.getAutomatonCell().hasBackgroundFlag())
      continue;
 
    if (m_param_rejectIfNotTakenFlag
        && !wireHit.getAutomatonCell().hasTakenFlag())
      continue;
 
    // the taken flag is also set for background hits. Therefore we must
    // also hits to be also classified as background to not get flooded
    // with background hits
    if (m_param_rejectIfNotTakenFlag
        && wireHit.getAutomatonCell().hasTakenFlag()
        && wireHit.getAutomatonCell().hasBackgroundFlag())
      continue;
 
    // Attention: at this stage we use the drift time that was set when the WireHits were created.
    // We will just *assume* that it was zero at this time!
    timingHistgram.Fill(wireHit.getDriftTime());
  }
 
  if (timingHistgram.GetEntries() < m_param_minHitCount) {
    B2DEBUG(25, "Only " << timingHistgram.GetEntries() << " hits satisfied the requirements for t0 extraction, " << m_param_minHitCount
            << " are required.");
    return;
  }
 
  // add an overall offset of 1 to not have to care about empty bins in
  // the cumulated plot
  timingHistgram.SetBinContent(1, timingHistgram.GetBinContent(1) + 1);
 
  B2DEBUG(25,
          "Filled histogram with " << timingHistgram.GetEntries() << " Entries");
 
  std::unique_ptr<TH1> cumTimingHistogram(timingHistgram.GetCumulative());
  // detach histogram from any directory so we can delete it ourselves
  cumTimingHistogram->SetDirectory(0);
 
  // set the error for each bin taking into account that the bin content is the
  // cumulated content of previous bins
  double errPrevBin = 0.0f;
  double errThisBin = 0.0f;
  for (int i = 0; i < cumTimingHistogram->GetNbinsX(); i++) {
    if (i > 0) {
      const double prevEntries = cumTimingHistogram->GetBinContent(i - 1);
      const double addedEntries = cumTimingHistogram->GetBinContent(i) - prevEntries;
      if (addedEntries > 0.0) {
        // combine the error of the previous bin with the new entries of this bin
        const double errNewEntries = 1.0 / std::sqrt(addedEntries);
        errThisBin = errPrevBin + errNewEntries;
      }
 
    } else {
      if (cumTimingHistogram->GetBinContent(i) > 0) {
        errThisBin = 1.0 / std::sqrt(cumTimingHistogram->GetBinContent(i));
      }
    }
 
    cumTimingHistogram->SetBinError(i, errThisBin);
    errPrevBin = errThisBin;
  }
 
  if (m_param_storeAllFits) {
    cumTimingHistogram->Draw();
  }
 
  auto rangeBkg = std::make_pair(-m_param_fitWindow, -m_param_searchWindow);
  auto rangeSig = std::make_pair(m_param_searchWindow, m_param_fitWindow);
  // fit the background and signal side of the time distribution
  TF1 fitfuncBkg = TF1("HitBasedT0Extractor_fit_bkg", "[0]*x + [1]",
                       rangeBkg.first, rangeBkg.second);
  TF1 fitfuncSig = TF1("HitBasedT0Extractor_fit_sig", "[0]*x + [1]",
                       rangeSig.first, rangeSig.second);
 
  auto fitresBkg = cumTimingHistogram->Fit(&fitfuncBkg, "LQS", "",
                                           rangeBkg.first, rangeBkg.second);
  auto fitresSig = cumTimingHistogram->Fit(&fitfuncSig, "LQS", "",
                                           rangeSig.first, rangeSig.second);
 
  if (m_param_storeAllFits) {
    fitfuncBkg.Draw("SAME");
    fitfuncSig.Draw("SAME");
  }
 
  TF1 fitfuncSegmented = TF1("HitBasedT0Extractor_fit_seg",
                             "[1]*(x+TMath::Abs(x+[3])) + [2]*(x-TMath::Abs(x+[3])) + [0]",
                             -m_param_fitWindow, m_param_fitWindow);
 
  if (fitresSig->IsValid() && fitresBkg->IsValid()) {
    double t0_estimate = (fitresBkg->Parameter(1) - fitresSig->Parameter(1))
                         / (fitresSig->Parameter(0) - fitresBkg->Parameter(0));
 
    // apply segmented fit
    std::array<double, 4> fit_params = { 0,  // = overall background offset
                                         fitresSig->Parameter(0),  // signal hits slope
                                         fitresBkg->Parameter(0), // background hits slope
                                         0.0 // breaking point shift
                                       };
 
    // use t0 estimate if it is something useful
    if (std::abs(t0_estimate) < m_param_searchWindow) {
      fit_params[3] = t0_estimate;
    }
 
    fitfuncSegmented.SetParameters(fit_params.data());
 
    auto fitresFull = cumTimingHistogram->Fit(&fitfuncSegmented, "QS", "", -m_param_fitWindow, m_param_fitWindow);
    if (m_param_storeAllFits) {
      fitfuncSegmented.Draw("SAME");
    }
 
    // refit with a fixed window around the extracted t0 to remove a possible bias
    // because we fitted a large part of the signal side in the first iteration
    const double fitted_t0_first = -fitresFull->Parameter(3);
    bool refitSuccess = false;
    if (std::abs(fitted_t0_first) < m_param_searchWindow) {
      fitresFull = cumTimingHistogram->Fit(&fitfuncSegmented, "QS", "",
                                           fitted_t0_first - m_param_refitWindow, fitted_t0_first + m_param_refitWindow);
      refitSuccess = true;
    } else {
      B2DEBUG(25, "First t0 estimate not in proper range" << fitted_t0_first);
    }
 
    if (m_param_storeAllFits) {
      fitfuncSegmented.Draw("SAME");
    }
 
    // actually store this result ?
    if (refitSuccess && fitresFull->IsValid()) {
      const double fitted_t0 = -fitresFull->Parameter(3);
      const double fitted_t0_error = fitresFull->Error(3);
 
      const double norm_chi2 = fitresFull->Chi2() / double(fitresFull->Ndf());
 
      B2DEBUG(25, "T0 fit with t0 " << fitted_t0 << " +- " << fitted_t0_error << " and normalized chi2 " << norm_chi2 << " and " <<
              timingHistgram.GetEntries() << " hits");
 
      // check if all the criteria required for a "good fit" have been met
      if (norm_chi2 > m_param_rejectIfChiSquareLargerThan) {
        B2DEBUG(25,
                "T0 fit has too large Chi2 " << fitresFull->Chi2());
      } else if (std::abs(fitted_t0_error) > m_param_rejectIfUncertaintyLargerThan) {
        B2DEBUG(25,
                "T0 fit has too large error " << fitted_t0_error);
      } else {
 
        // Since drift times are corrected for EventT0 (in RealisticTDCCountTranslator), if any other T0 modules were executed before, add the EventT0 offset back.
        // This leads to "absolute" event T0 determination which should be consistent with other T0 modules.
        double lastEventT0 = m_eventT0->hasEventT0() ? m_eventT0->getEventT0() : 0;
        EventT0::EventT0Component eventT0Component(fitted_t0 + lastEventT0, fitted_t0_error, Const::CDC, "hit based", norm_chi2);
        m_eventT0->addTemporaryEventT0(eventT0Component);
        m_eventT0->setEventT0(eventT0Component);
        m_wasSuccessful = true;
        B2DEBUG(25,
                "Successful t0 extraction with CDC hits: " << fitted_t0 << " +- " << fitted_t0_error);
      }
    } else {
      B2DEBUG(25,
              "Cannot fit t0 from CDC hits only. Won't set EventT0 for now.");
    }
  } else {
    B2DEBUG(25,
            "Cannot extract background or signal segment because fit failed. Won't set EventT0 for now.");
  }
 
  if (m_param_storeAllFits) {
    canvas.Draw();
    canvas.SaveAs(debugImageName.c_str());
  }
}

beginEvent()

void beginEvent

overridevirtualinherited

Create the event t0 store obj ptr.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 39 of file BaseEventTimeExtractor.icc.h.

  {
    Super::beginEvent();
 
    m_wasSuccessful = false;
 
    if (not m_eventT0.isValid()) {
      m_eventT0.create();
    }
 
    m_eventT0Before = m_eventT0->getEventT0Component();
  }

beginRun()

void beginRun ( )

overridevirtualinherited

Receive and dispatch signal for the beginning of a new run.

Reimplemented from ProcessingSignalListener.

Reimplemented in LayerRelationFilter< AFilter >, FourHitFilter, QualityIndicatorFilter, ThreeHitFilter, TwoHitVirtualIPFilter, TwoHitVirtualIPQIFilter, RecoTrackStorer, ROIFinder, SpacePointLoaderAndPreparer, and TrackCandidateResultRefiner.

Definition at line 23 of file CompositeProcessingSignalListener.cc.

{
  Super::beginRun();
  for (ProcessingSignalListener* psl : m_subordinaryProcessingSignalListeners) {
    psl->beginRun();
  }
}

endRun()

void endRun ( )

overridevirtualinherited

Receive and dispatch signal for the end of the run.

Reimplemented from ProcessingSignalListener.

Definition at line 39 of file CompositeProcessingSignalListener.cc.

{
  for (ProcessingSignalListener* psl : reversedRange(m_subordinaryProcessingSignalListeners)) {
    psl->endRun();
  }
  Super::endRun();
}

exposeParameters()

void exposeParameters ( ModuleParamList *  moduleParamList, const std::string &  prefix  )

finaloverridevirtual

Expose the parameters to a module.

Reimplemented from BaseEventTimeExtractor< TrackFindingCDC::CDCWireHit & >.

Definition at line 41 of file HitBasedT0Extractor.cc.

{
  moduleParamList->addParameter(prefixed(prefix, "searchWindow"),
                                m_param_searchWindow,
                                "Size of the time distance (in ns) to search for t0 in both direction from the current best t0",
                                m_param_searchWindow);
 
  moduleParamList->addParameter(prefixed(prefix, "fitWindow"),
                                m_param_fitWindow,
                                "Size of the time distance (in ns) to used for fitting",
                                m_param_fitWindow);
 
  moduleParamList->addParameter(prefixed(prefix, "refitWindow"),
                                m_param_refitWindow,
                                "Size of the time distance (in ns) to used for re-fitting",
                                m_param_refitWindow);
 
  moduleParamList->addParameter(prefixed(prefix, "binCountTimeHistogram"),
                                m_param_binCountTimeHistogram,
                                "Number of bins in the timing histogram used for fitting",
                                m_param_binCountTimeHistogram);
 
  moduleParamList->addParameter(prefixed(prefix, "rejectByBackgroundFlag"),
                                m_param_rejectByBackgroundFlag,
                                "Don't consider hits if they have the background flag set",
                                m_param_rejectByBackgroundFlag);
 
  moduleParamList->addParameter(prefixed(prefix, "rejectIfNotTakenFlag"),
                                m_param_rejectIfNotTakenFlag,
                                "Don't consider hits which have not been assigned during track finding. The CDC track finding has "
                                "to be run before for this flag to be useful.",
                                m_param_rejectIfNotTakenFlag);
 
  moduleParamList->addParameter(prefixed(prefix, "rejectIfChiSquareLargerThan"),
                                m_param_rejectIfChiSquareLargerThan,
                                "consider the t0 fit failed which have larger chi2 than this number",
                                m_param_rejectIfChiSquareLargerThan);
 
  moduleParamList->addParameter(prefixed(prefix, "rejectIfUncertaintyLargerThan"),
                                m_param_rejectIfUncertaintyLargerThan,
                                "consider the t0 fit if the uncertainty on t0 is larger than this value",
                                m_param_rejectIfUncertaintyLargerThan);
 
  moduleParamList->addParameter(prefixed(prefix, "storeAllFits"),
                                m_param_storeAllFits,
                                "store images for all fits",
                                m_param_storeAllFits);
 
  moduleParamList->addParameter(prefixed(prefix, "minHitCount"),
                                m_param_minHitCount,
                                "Minimum amount of hits which is required to try the extraction",
                                m_param_minHitCount);
 
  Super::exposeParameters(moduleParamList, prefix);
}

getDescription()

std::string getDescription ( )

finaloverridevirtual

Short description of the findlet.

Reimplemented from Findlet< AIOTypes... >.

Definition at line 30 of file HitBasedT0Extractor.cc.

{
  return "Extracts the T0 time of an event only using CDC Hits";
}

getNProcessingSignalListener()

int getNProcessingSignalListener ( )

protectedinherited

Get the number of currently registered listeners.

Definition at line 60 of file CompositeProcessingSignalListener.cc.

{
  return m_subordinaryProcessingSignalListeners.size();
}

initialize()

void initialize ( )

finaloverridevirtual

Initialize the event meta data.

Reimplemented from BaseEventTimeExtractor< TrackFindingCDC::CDCWireHit & >.

Definition at line 35 of file HitBasedT0Extractor.cc.

{
  m_eventMetaData.isRequired();
  Super::initialize();
}

resetEventT0()

void resetEventT0

protectedinherited

Reset the t0 value to cached value if it exists or clear it otherwise.

Definition at line 43 of file BaseEventTimeExtractor.icc.h.

  {
    if (m_eventT0Before) {
      m_eventT0->setEventT0(*m_eventT0Before);
    } else {
      m_eventT0->clearEventT0();
    }
  }

terminate()

void terminate ( )

overridevirtualinherited

Receive and dispatch Signal for termination of the event processing.

Reimplemented from ProcessingSignalListener.

Reimplemented in StereoHitTrackQuadTreeMatcher< Belle2::TrackFindingCDC::HyperHough >, StereoHitTrackQuadTreeMatcher< Belle2::TrackFindingCDC::QuadraticLegendre >, and StereoHitTrackQuadTreeMatcher< Belle2::TrackFindingCDC::Z0TanLambdaLegendre >.

Definition at line 47 of file CompositeProcessingSignalListener.cc.

{
  for (ProcessingSignalListener* psl : reversedRange(m_subordinaryProcessingSignalListeners)) {
    psl->terminate();
  }
  Super::terminate();
}

wasSuccessful()

bool wasSuccessful

inherited

Returns true if the last run t0 extraction was successful.

Definition at line 30 of file BaseEventTimeExtractor.icc.h.

  {
    return m_wasSuccessful;
  }

Member Data Documentation

m_eventMetaData

StoreObjPtr<EventMetaData> m_eventMetaData

private

access to event nr for debugging purposes

Definition at line 75 of file HitBasedT0Extractor.h.

m_eventT0

StoreObjPtr<EventT0> m_eventT0

protectedinherited

Pointer to the storage of the eventwise T0 estimation in the data store.

Definition at line 46 of file BaseEventTimeExtractor.dcl.h.

m_eventT0Before

std::optional<EventT0::EventT0Component> m_eventT0Before

privateinherited

Storage for the event t0 before this module ran.

Definition at line 56 of file BaseEventTimeExtractor.dcl.h.

m_initialized

bool m_initialized = false

privateinherited

Flag to keep track whether initialization happened before.

Definition at line 52 of file ProcessingSignalListener.h.

m_initializedAs

std::string m_initializedAs

privateinherited

Name of the type during initialisation.

Definition at line 58 of file ProcessingSignalListener.h.

m_param_binCountTimeHistogram

int m_param_binCountTimeHistogram = 50

private

number of bins in the timing histogram

Definition at line 60 of file HitBasedT0Extractor.h.

m_param_fitWindow

float m_param_fitWindow = 100.0f

private

the space (+-m_param_fitWindow) in ns used to fit the t0

Definition at line 58 of file HitBasedT0Extractor.h.

m_param_minHitCount

unsigned int m_param_minHitCount = 20

private

minimum number of hits

Definition at line 54 of file HitBasedT0Extractor.h.

m_param_overwriteExistingEstimation

bool m_param_overwriteExistingEstimation

privateinherited

Parameter if it is fine to overwrite the current EventT0.

Definition at line 53 of file BaseEventTimeExtractor.dcl.h.

m_param_refitWindow

float m_param_refitWindow = 50.0f

private

the width of the window in ns (+- m_param_refitWindow) used to refit the final t0 value

Definition at line 73 of file HitBasedT0Extractor.h.

m_param_rejectByBackgroundFlag

bool m_param_rejectByBackgroundFlag = false

private

don't use hits for the fit which have been flagged as background

Definition at line 62 of file HitBasedT0Extractor.h.

m_param_rejectIfChiSquareLargerThan

float m_param_rejectIfChiSquareLargerThan = std::numeric_limits<float>::max()

private

largest allowable chi2 value

Definition at line 69 of file HitBasedT0Extractor.h.

m_param_rejectIfNotTakenFlag

bool m_param_rejectIfNotTakenFlag = true

private

don't use hits for the fit which have not been assigned to any track

Definition at line 64 of file HitBasedT0Extractor.h.

m_param_rejectIfUncertaintyLargerThan

float m_param_rejectIfUncertaintyLargerThan = 12.0f

private

largest allowable uncertainty value

Definition at line 71 of file HitBasedT0Extractor.h.

m_param_searchWindow

float m_param_searchWindow = 70.0f

private

the window (+-m_param_searchWindow) in ns where to search for the best t0

Definition at line 56 of file HitBasedT0Extractor.h.

m_param_storeAllFits

bool m_param_storeAllFits = false

private

store an image of the histogram and fit result, for debug purpose only

Definition at line 66 of file HitBasedT0Extractor.h.

m_subordinaryProcessingSignalListeners

std::vector<ProcessingSignalListener*> m_subordinaryProcessingSignalListeners

privateinherited

References to subordinary signal processing listener contained in this findlet.

Definition at line 52 of file CompositeProcessingSignalListener.h.

m_terminated

bool m_terminated = false

privateinherited

Flag to keep track whether termination happened before.

Definition at line 55 of file ProcessingSignalListener.h.

m_wasSuccessful

bool m_wasSuccessful

protectedinherited

Variable to show that the execution was successful.

Definition at line 49 of file BaseEventTimeExtractor.dcl.h.

---

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

• tracking/eventTimeExtraction/findlets/include/HitBasedT0Extractor.h
• tracking/eventTimeExtraction/findlets/src/HitBasedT0Extractor.cc