TrackTimeDefAndQualityAlg.h

Go to the documentation of this file.

 
#ifndef HGTD_RECALGS_TRACKTIMEDEFANDQUALITYALG_H
#define HGTD_RECALGS_TRACKTIMEDEFANDQUALITYALG_H
 
#include "AthenaBaseComps/AthReentrantAlgorithm.h"
 
#include "StoreGate/ReadDecorHandleKey.h"
#include "StoreGate/WriteDecorHandleKey.h"
#include "xAODTracking/TrackParticle.h"
#include "xAODTracking/TrackParticleContainer.h"
 
namespace {
static constexpr unsigned short s_hgtd_layers = 4; // two double sided layers
} // namespace
 
namespace HGTD {
 
class TrackTimeDefAndQualityAlg : public AthReentrantAlgorithm {
 
private:
  // different shift distances for bitfield definition
  const short m_recoed_ptrn_sft = 0;
  //const short m_exp_ptrn_sft = 4;
  const short m_comp_ptrn_sft = 8;
  const short m_holes_ptrn_sft = 12;
  const short m_primes_ptrn_sft = 16;
 
public:
  TrackTimeDefAndQualityAlg(const std::string& name, ISvcLocator* pSvcLocator);
  virtual ~TrackTimeDefAndQualityAlg() {}
  virtual StatusCode initialize() override final;
  virtual StatusCode execute(const EventContext& ctx) const override final;
 
private:
  std::pair<float, float> getRadiusAndZ(const xAOD::TrackParticle& track_particle) const;
  
private:
  SG::ReadHandleKey<xAOD::TrackParticleContainer> m_trackParticleContainerKey{
      this, "TrackParticleContainerName", "InDetTrackParticles",
      "Name of the TrackParticle container"};
 
  SG::ReadDecorHandleKey<xAOD::TrackParticleContainer> m_layerHasExtensionKey{
    this, "HGTD_has_extension", m_trackParticleContainerKey, "HGTD_has_extension",
      "deco with a handle for an extension"};
  SG::ReadDecorHandleKey<xAOD::TrackParticleContainer> m_layerClusterTimeKey{
    this, "HGTD_cluster_time", m_trackParticleContainerKey, "HGTD_cluster_time",
      "deco with a handle for cluster time"};
  SG::ReadDecorHandleKey<xAOD::TrackParticleContainer>
      m_layerClusterTruthClassKey{
    this, "HGTD_cluster_truth_class", m_trackParticleContainerKey,
          "HGTD_cluster_truth_class",
          "deco with a handle for a truth time"};
 
  SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> m_time_dec_key{
    this, "time", m_trackParticleContainerKey, "time", "Time assigned to this track"};
  SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> m_time_res_dec_key{
    this, "timeResolution", m_trackParticleContainerKey, "timeResolution",
      "Time resolution assigned to this track"};
  SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> m_hasValidTime_dec_key{
    this, "hasValidTime", m_trackParticleContainerKey, "hasValidTime", "Time assigned to this track is valid"};
  SG::WriteDecorHandleKey<xAOD::TrackParticleContainer>
  m_summarypattern_dec_key{this, "HGTD_summaryinfo", m_trackParticleContainerKey,
                               "HGTD_summaryinfo",
                               "Bitfield for working point definition"};
 
  Gaudi::Property<bool> m_doActs {this, "doActs", false};
  
  // TODO: the resolution is fixed to 0.035 ps, should add the resolution
  // calculation after the irradiation
  struct Hit {
    float m_time = 0.;
    float m_resolution = 0.035;
    bool m_isprime = false;
    bool m_isvalid = false;
    short m_layer = -1;
  };
 
  struct CleaningResult {
    std::array<Hit, s_hgtd_layers> m_hits;
    uint32_t m_field = 0x0;
    float m_time;
    float m_resolution;
    uint8_t m_hasValidTime;
  };
 
  FloatProperty m_chi2_threshold{
      this, "Chi2Threshold", 1.5,
      "Quality cut for decision to keep hits compatible in time"};
  FloatProperty m_deltat_cut{this, "DeltaTCut", 2.0,
                             "Upper limit for a cluster delta t cut"};
 
  FloatProperty m_default_time{
      this, "DefaultTime", 0.0,
      "Default time used for tracks without HGTD timing info"};
  // time resolution default value, set to +- half a bunch crossing, using flat
  // distribution
  FloatProperty m_default_time_res{
      this, "DefaultTimeRes", 50. / std::sqrt(12.),
      "Default time resolution used for tracks without HGTD timing info"};
 
  CleaningResult
  runTimeConsistencyCuts(const std::vector<float>& times,
             const std::vector<bool>& has_clusters,
             const std::vector<int>& hit_classification) const;
 
  std::array<Hit, s_hgtd_layers>
  getValidHits(const std::vector<float>& times,
           const std::vector<bool>& has_clusters,
           const std::vector<int>& hit_classification) const;
 
  float calculateChi2(const std::array<Hit, s_hgtd_layers>& hits) const;
 
  // float calculateChi2(const std::vector<Hit>& hits) const;
 
  bool passesDeltaT(const std::array<Hit, s_hgtd_layers>& hits) const;
 
  float meanTime(const std::array<Hit, s_hgtd_layers>& hits) const;
 
  float trackTimeResolution(const std::array<Hit, s_hgtd_layers>& hits) const;
 
  short findLayerWithBadChi2(std::array<Hit, s_hgtd_layers> hits) const;
 
  void setLayerAsInvalid(std::array<Hit, s_hgtd_layers>& hits,
                         short layer) const;
 
  short getValidPattern(const std::array<Hit, s_hgtd_layers>& hits) const;
 
  bool lastHitIsOnLastSurface(const xAOD::TrackParticle& track_particle) const;
 
  const Trk::TrackParameters* getLastHitOnTrack(const Trk::Track& track) const;
};
 
} // namespace HGTD
 
#endif // HGTD_RECALGS_TRACKTIMEDEFANDQUALITYALG_H