MaterialEffectsUpdator.h

Go to the documentation of this file.

/*
   Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
 */

// MaterialEffectsUpdator.h, c) ATLAS Detector software
 
#ifndef TRKEXTOOLS_MATERIALEFFECTSUPDATOR_H
#define TRKEXTOOLS_MATERIALEFFECTSUPDATOR_H
 
#include "TrkExInterfaces/IMaterialEffectsUpdator.h"
// Trk
#include "TrkEventPrimitives/PropDirection.h"
#include "TrkExUtils/MaterialUpdateMode.h"
#include "TrkParameters/TrackParameters.h"
#include "TrkExInterfaces/IEnergyLossUpdator.h"
#include "TrkExInterfaces/IMultipleScatteringUpdator.h"
#include "TrkDetDescrInterfaces/IMaterialMapper.h"
// Gaudi
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ToolHandle.h"
 
#include <string>
#include <vector>
 
#include <boost/thread/tss.hpp>
 
namespace Trk {
 
class Layer;
// class TrackParameters;
class MaterialProperties;

 
class MaterialEffectsUpdator final
  : public AthAlgTool
  , virtual public IMaterialEffectsUpdator
{
 
public:
  MaterialEffectsUpdator(const std::string&,
                         const std::string&,
                         const IInterface*);

  virtual ~MaterialEffectsUpdator();

  virtual StatusCode initialize() override;
  /*
   * The concrete cache class for this specialization of the
   * IMaterialEffectsUpdator
   */
  typedef IMaterialEffectsUpdator::ICache ICache;
  virtual std::unique_ptr<TrackParameters> update(
    ICache& cache,
    const TrackParameters* parm,
    const Layer& sf,
    PropDirection dir = alongMomentum,
    ParticleHypothesis particle = pion,
    MaterialUpdateMode matupmode = addNoise) const override
  {
    return updateImpl(cache, parm, sf, dir, particle, matupmode);
  }

  virtual std::unique_ptr<TrackParameters> update(
    ICache& cache,
    const TrackParameters* parm,
    const MaterialEffectsOnTrack& meff,
    Trk::ParticleHypothesis particle = pion,
    MaterialUpdateMode matupmode = addNoise) const override
  {
    return updateImpl(cache, parm, meff, particle, matupmode);
  }

  virtual std::unique_ptr<TrackParameters> preUpdate(
    ICache& cache,
    const TrackParameters* parm,
    const Layer& sf,
    PropDirection dir = alongMomentum,
    ParticleHypothesis particle = pion,
    MaterialUpdateMode matupmode = addNoise) const override
  {
    return preUpdateImpl(cache, parm, sf, dir, particle, matupmode);
  }

  virtual std::unique_ptr<TrackParameters> postUpdate(
    ICache& cache,
    const TrackParameters& parm,
    const Layer& sf,
    PropDirection dir = alongMomentum,
    ParticleHypothesis particle = pion,
    MaterialUpdateMode matupmode = addNoise) const override final
  {
    return postUpdateImpl(cache, parm, sf, dir, particle, matupmode);
  }

  virtual std::unique_ptr<TrackParameters> update(
    ICache& cache,
    const TrackParameters& parm,
    const MaterialProperties& mprop,
    double pathcorrection,
    PropDirection dir = alongMomentum,
    ParticleHypothesis particle = pion,
    MaterialUpdateMode matupmode = addNoise) const override final
  {
    return updateImpl(
      cache, parm, mprop, pathcorrection, dir, particle, matupmode);
  }

  virtual void validationAction(ICache& cache) const override final
  {
    validationActionImpl(cache);
  }

  virtual void modelAction(ICache& cache, const TrackParameters* parm = nullptr)
    const override final
  {
    modelActionImpl(cache, parm);
  }
 
public:
  /*
   * Public methods using the TLS cache.
   */
  virtual std::unique_ptr<TrackParameters> update(
    const TrackParameters* parm,
    const Layer& sf,
    PropDirection dir = alongMomentum,
    ParticleHypothesis particle = pion,
    MaterialUpdateMode matupmode = addNoise) const override final
  {
 
    ICache& cache = getTLSCache();
    return updateImpl(cache, parm, sf, dir, particle, matupmode);
  }
 
  virtual std::unique_ptr<TrackParameters> update(
    const TrackParameters* parm,
    const MaterialEffectsOnTrack& meff,
    Trk::ParticleHypothesis particle = pion,
    MaterialUpdateMode matupmode = addNoise) const override final
  {
    ICache& cache = getTLSCache();
    return updateImpl(cache, parm, meff, particle, matupmode);
  }
 
  virtual std::unique_ptr<TrackParameters> preUpdate(
    const TrackParameters* parm,
    const Layer& sf,
    PropDirection dir = alongMomentum,
    ParticleHypothesis particle = pion,
    MaterialUpdateMode matupmode = addNoise) const override final
  {
    ICache& cache = getTLSCache();
    return preUpdateImpl(cache, parm, sf, dir, particle, matupmode);
  }
 
  virtual std::unique_ptr<TrackParameters> postUpdate(
    const TrackParameters& parm,
    const Layer& sf,
    PropDirection dir = alongMomentum,
    ParticleHypothesis particle = pion,
    MaterialUpdateMode matupmode = addNoise) const override final
  {
    ICache& cache = getTLSCache();
    return postUpdateImpl(cache, parm, sf, dir, particle, matupmode);
  }
 
  virtual std::unique_ptr<TrackParameters> update(
    const TrackParameters& parm,
    const MaterialProperties& mprop,
    double pathcorrection,
    PropDirection dir = alongMomentum,
    ParticleHypothesis particle = pion,
    MaterialUpdateMode matupmode = addNoise) const override final
  {
    ICache& cache = getTLSCache();
    return updateImpl(
      cache, parm, mprop, pathcorrection, dir, particle, matupmode);
  }
 
  virtual void validationAction() const override final
  {
    ICache& cache = getTLSCache();
    validationActionImpl(cache);
  }
 
  virtual void modelAction(
    const TrackParameters* parm = nullptr) const override final
  {
    ICache& cache = getTLSCache();
    modelActionImpl(cache, parm);
  }
 
private:
  /* The acutal implementation methods using the tool's
   * concrete  Cache*/
  std::unique_ptr<TrackParameters> updateImpl(
    ICache& cache,
    const TrackParameters* parm,
    const Layer& sf,
    PropDirection dir = alongMomentum,
    ParticleHypothesis particle = pion,
    MaterialUpdateMode matupmode = addNoise) const;
 
  std::unique_ptr<TrackParameters> updateImpl(
    ICache& cache,
    const TrackParameters* parm,
    const MaterialEffectsOnTrack& meff,
    Trk::ParticleHypothesis particle = pion,
    MaterialUpdateMode matupmode = addNoise) const;
 
  std::unique_ptr<TrackParameters> preUpdateImpl(
    ICache& cache,
    const TrackParameters* parm,
    const Layer& sf,
    PropDirection dir = alongMomentum,
    ParticleHypothesis particle = pion,
    MaterialUpdateMode matupmode = addNoise) const;
 
  std::unique_ptr<TrackParameters> postUpdateImpl(
    ICache& cache,
    const TrackParameters& parm,
    const Layer& sf,
    PropDirection dir = alongMomentum,
    ParticleHypothesis particle = pion,
    MaterialUpdateMode matupmode = addNoise) const;
 
  std::unique_ptr<TrackParameters> updateImpl(
    ICache& cache,
    const TrackParameters* parm,
    const MaterialProperties& mprop,
    double pathcorrection,
    PropDirection dir = alongMomentum,
    ParticleHypothesis particle = pion,
    MaterialUpdateMode matupmode = addNoise) const;
 
  std::unique_ptr<TrackParameters> updateImpl(
    ICache& cache,
    const TrackParameters& parm,
    const MaterialProperties& mprop,
    double pathcorrection,
    PropDirection dir = alongMomentum,
    ParticleHypothesis particle = pion,
    MaterialUpdateMode matupmode = addNoise) const;
 
  static void validationActionImpl(ICache& cache);
 
  static void modelActionImpl(ICache& cache,
                              const TrackParameters* parm = nullptr);

  bool checkCovariance(AmgSymMatrix(5) & updated) const;
  TrackParameters* finalLandauCovarianceUpdate(
    const TrackParameters* parm) const;
 
  /* Private Class members*/
  BooleanProperty m_doEloss{this, "EnergyLoss", true,
    "steer energy loss On/Off from outside"};
  BooleanProperty m_doMs{this, "MultipleScattering", true,
    "steer multiple scattering On/Off from outside"};
 
  BooleanProperty m_forceMomentum{this, "ForceMomentum", false,
    "Force the momentum to be a specific value"};
  BooleanProperty m_useMostProbableEloss{this, "MostProbableEnergyLoss", false,
    "use the most probable energy loss"};
 
  BooleanProperty m_msgOutputValidationDirection
    {this, "ScreenOutputValidationDirection", true,
     "validation direction used for screen output"};
  BooleanProperty m_msgOutputCorrections{this, "ScreenOutputCorrections", false,
    "screen output of actual corrections"};
 
  // ------------ validation variables
  // -------------------------------------------------
  BooleanProperty m_validationMode{this, "ValidationMode", false,
    "Switch for validation mode"};
  BooleanProperty m_validationIgnoreUnmeasured
    {this, "ValidationIgnoreUnmeasured", false,
     "Ignore unmeasured TrackParameters (Navigation!)"};
  BooleanProperty m_landauMode{this, "LandauMode", false,
    "If in Landau mode, error propagation is done as for landaus"};
  IntegerProperty m_validationDirection{this, "ValidationDirection", 1,
    "validation direction"};
  //  ------------------------------
  DoubleProperty m_momentumCut{this, "MinimalMomentum", 50. * Gaudi::Units::MeV,
    "Minimal momentum cut for update"};
  DoubleProperty m_momentumMax{this, "MaximalMomentum", 10. * Gaudi::Units::TeV,
    "Maximal momentum cut for update"};
  DoubleProperty m_forcedMomentum
    {this, "ForcedMomentumValue", 2000. * Gaudi::Units::MeV, "Forced momentum value"};
 
  ToolHandle<IEnergyLossUpdator> m_eLossUpdator
    {this, "EnergyLossUpdator", "Trk::EnergyLossUpdator/AtlasEnergyLossUpdator",
    "AlgoTool for EnergyLoss updates"};
  ToolHandle<IMultipleScatteringUpdator> m_msUpdator
    {this, "MultipleScatteringUpdator",
     "Trk::MultipleScatteringUpdator/AtlasMultipleScatteringUpdator",
     "AlgoTool for MultipleScatterin effects"};
  ToolHandle<IMaterialMapper> m_materialMapper
    {this, "ValidationMaterialMapper", "Trk::MaterialMapper/AtlasMaterialMapper",
     "the material mapper for recording the layer material"};
 
  /*
   * TLS part
   */
  mutable boost::thread_specific_ptr<ICache> m_cache_tls;
  ICache& getTLSCache() const
  {
    ICache* cache = m_cache_tls.get();
    if (!cache) {
      cache = new ICache();
      m_cache_tls.reset(cache);
    }
    return *cache;
  }
};
} // end of namespace
 
#endif // TRKEXTOOLS_MATERIALEFFECTSUPDATOR_H