MaterialEffectsUpdator.h

Go to the documentation of this file.

/*
   Copyright (C) 2002-2022 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"
// Gaudi
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ToolHandle.h"
 
#include <string>
#include <vector>
 
#include <boost/thread/tss.hpp>
 
#define TRKEXTOOLS_MAXUPDATES 100
#ifndef COVARIANCEUPDATEWITHCHECK
#define COVARIANCEUPDATEWITHCHECK(cov, sign, value)                            \
  cov += (sign > 0 ? value : (value > cov ? 0 : sign * value))
#endif
 
namespace Trk {
 
class Layer;
// class TrackParameters;
class MaterialProperties;
class IEnergyLossUpdator;
class IMultipleScatteringUpdator;
class IMaterialMapper;
 
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*/
  bool m_doCompoundLayerCheck; 
  bool m_doEloss;              
  bool m_doMs;                 
 
  bool m_forceMomentum;        
  bool m_xKalmanStraggling;    
  bool m_useMostProbableEloss; 
 
  bool m_msgOutputValidationDirection; 
  bool m_msgOutputCorrections;         
 
  // ------------ validation variables
  // -------------------------------------------------
  bool m_validationMode;             
  bool m_validationIgnoreUnmeasured; 
  bool m_landauMode;                 
  int m_validationDirection;         
  //  ------------------------------
  double m_momentumCut;    
  double m_momentumMax;    
  double m_forcedMomentum; 
 
  ToolHandle<IEnergyLossUpdator> m_eLossUpdator;      
  ToolHandle<IMultipleScatteringUpdator> m_msUpdator; 
  ToolHandle<IMaterialMapper> m_materialMapper; 
 
  /*
   * 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