LocalExtrapolatorCache.h

Go to the documentation of this file.

/*
   Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
 */
 
#ifndef TRKEXTOOLS_LOCALEXCACHE_H
#define TRKEXTOOLS_LOCALEXCACHE_H
#include "ObjContainer.h"
#include "TrkParameters/TrackParameters.h"
#include "ParametersNextVolume.h"
#include "TrkExInterfaces/IMaterialEffectsUpdator.h"
#include "TrkGeometry/TrackingGeometry.h" //because of m_trackingGeometry-> in header
#include "TrkExInterfaces/INavigator.h"  //using navigator. in this header
#include <utility>
#include <vector>
#include <string>
#include <memory>
 
 namespace Trk{
   class Surface;
   class ExtrapolationCache;
   class EnergyLoss;
   class TrackStateOnSurface;
 }
 
namespace Trk{
struct Cache
  {
    using TrackParmContainer = ObjContainer<Trk::TrackParameters>;
    using ManagedTrackParmPtr = ObjPtr<Trk::TrackParameters>;
    typedef std::vector<std::unique_ptr<Trk::TrackParameters>> TrackParametersUVector;
    typedef std::vector<std::pair<std::unique_ptr<Trk::TrackParameters>, int>> identifiedParameters_t;
    using TrackParmPtr = ObjRef;
    typedef std::pair<const Surface*, BoundaryCheck> DestSurf;
    //
    TrackParmContainer m_trackParmContainer;
    ManagedTrackParmPtr m_lastValidParameters;
    ParametersNextVolume m_parametersAtBoundary;
    std::vector<Trk::IMaterialEffectsUpdator::ICache> m_MaterialUpCache;
    bool m_dense = false;
    bool m_recall = false;
    bool m_robustSampling = true;
    unsigned int m_layerResolved{};
    unsigned int m_methodSequence = 0;
    const Surface* m_destinationSurface = nullptr;
    const Volume* m_boundaryVolume = nullptr;
    const Surface* m_recallSurface = nullptr;
    const Layer* m_recallLayer = nullptr;
    const TrackingVolume* m_recallTrackingVolume = nullptr;
    const Trk::TrackingVolume* m_currentStatic = nullptr;
    const Trk::TrackingVolume* m_currentDense = nullptr;
    const Trk::TrackingVolume* m_highestVolume = nullptr;
    //to a vector of unique parameters of detector elements
    TrackParametersUVector* m_parametersOnDetElements = nullptr;
    const Layer* m_lastMaterialLayer = nullptr;
    Trk::ExtrapolationCache* m_extrapolationCache = nullptr;
    const Trk::EnergyLoss* m_cacheEloss = nullptr;
    std::vector<const Trk::TrackStateOnSurface*>* m_matstates = nullptr;
    // for active volumes
    std::unique_ptr<identifiedParameters_t> m_identifiedParameters;
 
    const Trk::TrackingGeometry *m_trackingGeometry = nullptr;
    double m_path{};
 
    std::pair<unsigned int, unsigned int> m_denseResolved;
 
    std::vector<DestSurf> m_staticBoundaries;
    std::vector<DestSurf> m_detachedBoundaries;
    std::vector<DestSurf> m_denseBoundaries;
    std::vector<DestSurf> m_navigBoundaries;
    std::vector<DestSurf> m_layers;
 
    std::vector<std::pair<const Trk::DetachedTrackingVolume*, unsigned int>> m_detachedVols;
    std::vector<std::pair<const Trk::TrackingVolume*, unsigned int>> m_denseVols;
    std::vector<std::pair<const Trk::TrackingVolume*, const Trk::Layer*>> m_navigLays;
    std::vector<std::pair<const Trk::Surface*, Trk::BoundaryCheck>> m_navigSurfs;
    std::vector<const Trk::DetachedTrackingVolume*> m_navigVols;
    std::vector<std::pair<const Trk::TrackingVolume*, unsigned int>> m_navigVolsInt;
    
    //methods
    Cache();
    ~Cache();
    Cache(const std::vector<const IMaterialEffectsUpdator*> & updaters);
 
    TrackParmContainer& trackParmContainer() { return m_trackParmContainer; }
 
    ManagedTrackParmPtr manage(std::unique_ptr<Trk::TrackParameters>&& parm)
    {
      return ManagedTrackParmPtr(trackParmContainer(), std::move(parm));
    }
    ManagedTrackParmPtr manage(TrackParmPtr parm)
    {
      return ManagedTrackParmPtr(trackParmContainer(), parm);
    }
    ManagedTrackParmPtr manage() { return ManagedTrackParmPtr(trackParmContainer()); }
 
    const Trk::TrackingGeometry *trackingGeometry( const Trk::INavigator &navigator, const EventContext &ctx) {
       if (!m_trackingGeometry) {
          m_trackingGeometry = navigator.trackingGeometry(ctx);
       }
       return m_trackingGeometry;
    }
 
    const Trk::TrackingVolume 
    *volume(const EventContext&, const Amg::Vector3D& gp) const {
       assert(m_trackingGeometry);
       return m_trackingGeometry->lowestTrackingVolume(gp);
    }
    
    IMaterialEffectsUpdator::ICache& 
    subMaterialEffectsUpdatorCache(const TrackingVolume& tvol) ;
    
    IMaterialEffectsUpdator::ICache& 
    subMaterialEffectsUpdatorCache() ;
    
    //
    void
    populateMatEffUpdatorCache(const std::vector<const IMaterialEffectsUpdator*> & updaters);
    
    void 
    setRecallInformation(const Surface&,const Layer&,const TrackingVolume&);
    
    void
    resetRecallInformation();
    
    std::string 
    to_string(const std::string& txt) const;
    
    bool
    elossPointerOverwritten() const;
    
    std::string
    elossPointerErrorMsg(int lineNumber=0) const;
    
    void
    retrieveBoundaries();
    
    void
    addOneNavigationLayer(const Trk::TrackingVolume* pDetVol, const Trk::Layer* pLayer, bool boundaryCheck=true);
    
    void
    addOneNavigationLayer(const Trk::Layer* pLayer, bool boundaryCheck=true);
    
    void
    copyToNavigationSurfaces();
  };
  }
  #endif