Track.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#pragma once
#include <framework/gearbox/Const.h>
#include <framework/datastore/RelationsObject.h>
#include <mdst/dataobjects/TrackFitResult.h>
#include <algorithm>
 
namespace Belle2 {
  class Track : public RelationsObject {
  public:
 
    enum StatusBit {
 
      c_isFlippedAndRefitted = 1 << 0
 
    };
 
    typedef std::pair< Const::ChargedStable, TrackFitResult*> ChargedStableTrackFitResultPair;
 
    explicit Track(float qualityIndicator = 0.) : m_qualityIndicator(qualityIndicator)
    {
      std::fill(m_trackFitIndices, m_trackFitIndices + Const::chargedStableSet.size(), -1);
    }
 
    const TrackFitResult* getTrackFitResultByName(const Const::ChargedStable& chargedStable,
                                                  const std::string trackFitResultsName) const;
 
    const TrackFitResult* getTrackFitResult(const Const::ChargedStable& chargedStable) const;
 
 
    const TrackFitResult* getTrackFitResultWithClosestMassByName(const Const::ChargedStable& requestedType,
        const std::string trackFitResultsName) const;
 
    const TrackFitResult* getTrackFitResultWithClosestMass(const Const::ChargedStable& requestedType) const;
 
    std::vector<ChargedStableTrackFitResultPair> getTrackFitResultsByName(const std::string trackFitResultsName) const;
 
    std::vector<ChargedStableTrackFitResultPair> getTrackFitResults() const;
 
    void addStatusBits(unsigned short int bitmask) { m_statusBitmap |= bitmask; }
 
    void setFlippedAndRefitted() { addStatusBits(c_isFlippedAndRefitted); }
 
    bool getStatusBit(unsigned short int bitmask) const { return (m_statusBitmap & bitmask) == bitmask; }
 
    bool isFlippedAndRefitted() const { return getStatusBit(c_isFlippedAndRefitted); }
 
    bool wasRefined() { return m_statusBitmap > 0; }
 
    void setTrackFitResultIndex(const Const::ChargedStable& chargedStable, short index)
    {
      m_trackFitIndices[chargedStable.getIndex()] = index;
    }
 
    unsigned int getNumberOfFittedHypotheses() const;
 
    float getQualityIndicator() const
    {
      return m_qualityIndicator;
    }
 
    void setTrackTime(float track_time)
    {
      m_trackTime = track_time;
    }
 
    float getTrackTime() const
    {
      return m_trackTime;
    }
 
    virtual std::string getInfoHTML() const override;
 
  private:
 
    unsigned short int m_statusBitmap = 0;
 
    short int m_trackFitIndices[Const::ChargedStable::c_SetSize];
 
    std::vector < short int > getValidIndices() const;
 
    float const m_qualityIndicator;
 
    float m_trackTime = std::numeric_limits<float>::quiet_NaN();
 
    ClassDefOverride(Track, 6); 
    friend class FixMergedObjectsModule;
    friend class PostMergeUpdaterModule;
  };
}