ExpertTrackTimeFromClustersTool.h

Go to the documentation of this file.

 
#ifndef HGTD_EXPERTTRACKTIMEFROMCLUSTERSTOOL_H
#define HGTD_EXPERTTRACKTIMEFROMCLUSTERSTOOL_H
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "HGTD_Analysis/IHGTD_ExpertTrackTimeAccessor.h"
 
#include "AthContainers/ConstAccessor.h"
 
#include <memory>
#include <string>
#include <vector>
 
#include "TVector3.h"
 
namespace HGTD {
 
class ExpertTrackTimeFromClustersTool
    : public extends<AthAlgTool, IHGTD_ExpertTrackTimeAccessor> {
 
  struct Hit {
    float time;
    float resolution;
    bool isprime;
    TVector3 position;
  };
 
  using HitVec_t = std::vector<Hit>;
  using FloatVec_t = std::vector<float>;
 
public:
  ExpertTrackTimeFromClustersTool(const std::string&, const std::string&,
                                  const IInterface*);
 
  virtual ~ExpertTrackTimeFromClustersTool() = default;

  // for AthAlgTool interface
  virtual StatusCode initialize() override final;
 
  // for IHGTD_ExpertTrackTimeAccessor interface
 
  virtual bool
  expertHasTime(const xAOD::TrackParticle& track_particle) const override final;
 
  virtual float
  expertTime(const xAOD::TrackParticle& track_particle) const override final;
 
  virtual float
  expertTimeRes(const xAOD::TrackParticle& track_particle) const override final;
 
  virtual float
  fracPrimaryHits(const xAOD::TrackParticle& track_particle) const override final;
 
  virtual int numberPotentialPrimaryHits(
      const xAOD::TrackParticle& track_particle) const override final;

 
private:
  int nHits(const xAOD::TrackParticle& track_particle) const;

  int nPrimaryHits(const xAOD::TrackParticle& track_particle) const;

  HitVec_t getValidHits(const xAOD::TrackParticle& track_particle) const;

  HitVec_t getTimeCompatibleHits(const xAOD::TrackParticle& track_particle) const;

  TVector3 getLastMeasurement(const xAOD::TrackParticle& track) const;

  bool lastHitIsOnLastSurface(const xAOD::TrackParticle& track) const;

  float calculateMean(const HitVec_t& hits) const;

  bool passesDeltaT(const HitVec_t& hits) const;
 
  float calculateChi2(const HitVec_t& vals) const;
 
  float calculateTrackResolution(const HitVec_t& vals) const;
 
  int numberOfPrimaryHits(const HitVec_t& vals) const;
 
  Gaudi::Property<bool> m_do_last_hit{this, "UseLastHitCut", true,
                                      "Default value"};
  Gaudi::Property<bool> m_do_time_cons{this, "UseTimeConsistency", true,
                                       "Default value"};
  Gaudi::Property<float> m_deltat_cut{this, "DeltaTCut", 2.0, "Default value"};
  Gaudi::Property<float> m_chi2_threshold{this, "TimeChi2Cut", 1.5,
                                          "Default value"};
  Gaudi::Property<bool> m_do_min_nhits{this, "UseMinNHits", true,
                                       "Default value"};
  Gaudi::Property<float> m_min_eta{this, "MinEta", 3.5, "Default value"};
  Gaudi::Property<float> m_max_eta{this, "MaxEta", 3.9, "Default value"};
  Gaudi::Property<bool> m_do_smearing{this, "DoSmearing", false,
                                      "Default value"};

  std::string m_dec_prefix;
 
  std::unique_ptr<SG::AuxElement::Decorator<bool>> m_dec_isset;
  std::unique_ptr<SG::AuxElement::Decorator<bool>> m_dec_hastime;
  std::unique_ptr<SG::AuxElement::Decorator<float>> m_dec_time;
  std::unique_ptr<SG::AuxElement::Decorator<int>> m_dec_nhits;
  std::unique_ptr<SG::AuxElement::Decorator<int>> m_dec_nprimehits;
  std::unique_ptr<SG::AuxElement::Decorator<float>> m_dec_resolution;
 
  std::unique_ptr<SG::ConstAccessor<bool>> m_acc_isset;
  std::unique_ptr<SG::ConstAccessor<bool>> m_acc_hastime;
  std::unique_ptr<SG::ConstAccessor<float>> m_acc_time;
  std::unique_ptr<SG::ConstAccessor<int>> m_acc_nhits;
  std::unique_ptr<SG::ConstAccessor<int>> m_acc_nprimehits;
  std::unique_ptr<SG::ConstAccessor<float>> m_acc_resolution;

  SG::ConstAccessor<std::vector<bool>> m_acc_perLayer_hasCluster{
      "HGTD_has_extension"};
  SG::ConstAccessor<std::vector<float>> m_acc_perLayer_clusterTime{
      "HGTD_cluster_time"};
  SG::ConstAccessor<std::vector<int>> m_acc_perLayer_clusterTruthClass{
      "HGTD_cluster_truth_class"};
  SG::ConstAccessor<std::vector<bool>> m_acc_perLayer_expectCluster{
      "HGTD_primary_expected"};
};
 
} // namespace HGTD
 
#endif // HGTD_EXPERTTRACKTIMEFROMCLUSTERSTOOL_H