TrackStateOnSurface.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
/***************************************************************************
            TrackStateOnSurface.h  -  description
            -------------------
begin                : Wed Jan 21 2004
***************************************************************************/
 
#ifndef TRKTRACKSTATEONSURFACE_H
#define TRKTRACKSTATEONSURFACE_H
 
//
#include "TrkEventPrimitives/FitQualityOnSurface.h"
#include "TrkMaterialOnTrack/MaterialEffectsBase.h"
#include "TrkParameters/TrackParameters.h"
#include "TrkEventPrimitives/FitQualityOnSurface.h"
#include "TrkMeasurementBase/MeasurementBase.h"
#include "TrkTrack/AlignmentEffectsOnTrack.h"
//
//
#include <atomic>
#include <cstdint>
#include <bitset>
#include <iostream>
#include <memory>
 
class MsgStream;
class TrackCollectionCnv;
class TrackStateOnSurfaceCnv_p3;
 
namespace Trk {
class TrackStateOnSurface
{
  friend class ::TrackCollectionCnv;
  friend class ::TrackStateOnSurfaceCnv_p3;
 
public:
  /*
   * Historically, we had a single bitset.
   *
   * for types and hints.
   * The relevant indices in the bitset were controlled
   * by a single enum.
   *
   * For MT we split the hints from the types.
   * So we have two enums controlling two
   * bitsets.
   *
   * The types can be queried as before
   * from user code.
   *
   * The Hints exist only for
   * interacting with persistification
   * In order to support existing code
   * They are atomic and are to be set
   * only once for each TSOS.
   * they had to remain part of TSOS.
   */
  enum TrackStateOnSurfaceType
  {
    Measurement = 0,
 
    InertMaterial = 1,
 
    BremPoint = 2,
 
    Scatterer = 3,
 
    Perigee = 4,
 
    Outlier = 5,
 
    Hole = 6,
 
    Unknown = 7,
 
    CaloDeposit = 8,
 
    Parameter = 9,
 
    FitQuality = 10,
 
    Alignment = 11,
 
    NumberOfTrackStateOnSurfaceTypes = 12
  };
 
  enum PersistencyHint
  {
 
    PartialPersistification = 0,
    PersistifyMeasurement = 1,
 
    PersistifyTrackParameters = 2,
 
    PersistifySlimCaloDeposit = 3,
 
    NumberOfPersistencyHints = 4
  };
 
  /*
   * Helpers to join and split the bitsets
   * for the types and hints
   * Needed in order to keep the same T/P separation.
   * Note that in the Persistent side we keep a single ulong
   */
  static unsigned int long joinBitsets(
    const std::bitset<NumberOfTrackStateOnSurfaceTypes>& types,
    const std::bitset<NumberOfPersistencyHints>& hints)
  {
    //put hints in place
    unsigned int long res = hints.to_ulong();
    //shift them up
    res = (res << NumberOfTrackStateOnSurfaceTypes);
    //Add type
    res += types.to_ulong();
    return res;
  }
 
  static void splitToBitsets(
    const unsigned int long input,
    std::bitset<NumberOfTrackStateOnSurfaceTypes>& types,
    std::bitset<NumberOfPersistencyHints>& hints)
  {
    // mask with NumberOfTrackStateOnSurfaceTypes bits set to 1
    constexpr unsigned int long maskTypesSet =
      (1 << NumberOfTrackStateOnSurfaceTypes) - 1;
    //keep just the Type part of the input
    types = std::bitset<NumberOfTrackStateOnSurfaceTypes>(input & maskTypesSet);
    //keep the upper Hints part of the input
    hints = std::bitset<NumberOfPersistencyHints>(
      input >> NumberOfTrackStateOnSurfaceTypes);
  }
 
  enum Variety
  {
    SingleComponent = 0,
    MultiComponent = 1,
    Align = 2,
  };
  TrackStateOnSurface();
 
  explicit TrackStateOnSurface(
    const FitQualityOnSurface& fitQoS,
    std::unique_ptr<MeasurementBase> meas,
    std::unique_ptr<TrackParameters> trackParameters,
    std::unique_ptr<MaterialEffectsBase> materialEffects = nullptr,
    std::unique_ptr<AlignmentEffectsOnTrack> alignmentEffectsOnTrack = nullptr);
 
  explicit TrackStateOnSurface(
    std::unique_ptr<MeasurementBase> meas,
    std::unique_ptr<TrackParameters> trackParameters,
    std::unique_ptr<MaterialEffectsBase> materialEffects = nullptr,
    std::unique_ptr<AlignmentEffectsOnTrack> alignmentEffectsOnTrack = nullptr);
 
  explicit TrackStateOnSurface(
    const FitQualityOnSurface& fitQoS,
    std::unique_ptr<MeasurementBase> meas,
    std::unique_ptr<TrackParameters> trackParameters,
    std::unique_ptr<MaterialEffectsBase> materialEffectsOnTrack,
    const std::bitset<TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes>& typePattern,
    std::unique_ptr<AlignmentEffectsOnTrack> alignmentEffectsOnTrack = nullptr);
 
  explicit TrackStateOnSurface(
    std::unique_ptr<MeasurementBase> meas,
    std::unique_ptr<TrackParameters> trackParameters,
    std::unique_ptr<MaterialEffectsBase> materialEffectsOnTrack,
    const std::bitset<TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes>& typePattern,
    std::unique_ptr<AlignmentEffectsOnTrack> alignmentEffectsOnTrack = nullptr);
 
  virtual TrackStateOnSurface* clone() const;
 
  TrackStateOnSurface(const TrackStateOnSurface& trackStateOnSurface);
  TrackStateOnSurface(TrackStateOnSurface&& trackStateOnSurface) noexcept;
 
  /* Assignment */
  Trk::TrackStateOnSurface& operator=(const Trk::TrackStateOnSurface& rhs);
  Trk::TrackStateOnSurface& operator=(Trk::TrackStateOnSurface&& rhs) noexcept;
  virtual ~TrackStateOnSurface() = default;
 
  const FitQualityOnSurface& fitQualityOnSurface() const;
  FitQualityOnSurface& fitQualityOnSurface();
 
  const TrackParameters* trackParameters() const;
  TrackParameters* trackParameters();
 
  const MeasurementBase* measurementOnTrack() const;
  MeasurementBase* measurementOnTrack();
 
  const MaterialEffectsBase* materialEffectsOnTrack() const;
  MaterialEffectsBase* materialEffectsOnTrack();
 
  const AlignmentEffectsOnTrack* alignmentEffectsOnTrack() const;
  AlignmentEffectsOnTrack* alignmentEffectsOnTrack();
 
  bool type(const TrackStateOnSurfaceType type) const;
 
  virtual Trk::TrackStateOnSurface::Variety variety() const;
 
  std::string dumpType() const;
 
  const std::bitset<NumberOfTrackStateOnSurfaceTypes> types() const;
 
  void setHints(const uint8_t hints) const;
  const std::bitset<NumberOfPersistencyHints> hints() const;
 
  const Trk::Surface& surface() const;
  bool isSane() const;
 
private:
  void setFlags();
 
  FitQualityOnSurface m_fitQualityOnSurface{};
  std::unique_ptr<TrackParameters> m_trackParameters{};
  std::unique_ptr<MeasurementBase> m_measurementOnTrack{};
  std::unique_ptr<MaterialEffectsBase> m_materialEffectsOnTrack{};
  std::unique_ptr<AlignmentEffectsOnTrack> m_alignmentEffectsOnTrack{};
protected:
  uint16_t m_typeFlags{};
  mutable std::atomic<uint8_t> m_hints{};
};
 
MsgStream&
operator<<(MsgStream& sl, const TrackStateOnSurface& tsos);
 
std::ostream&
operator<<(std::ostream& sl, const TrackStateOnSurface& tsos);
}
 
#include "TrkTrack/TrackStateOnSurface.icc"
 
#endif