MaterialValidation.h

Go to the documentation of this file.

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

// MaterialValidation.h, (c) ATLAS Detector software
 
#ifndef TRKDETDESCRALGS_MATERIALVALIDATION_H
#define TRKDETDESCRALGS_MATERIALVALIDATION_H
 
// Gaudi includes
#include "AthenaBaseComps/AthAlgorithm.h"
#include "GaudiKernel/IRndmGenSvc.h"
#include "GaudiKernel/RndmGenerators.h"
#include "GaudiKernel/ToolHandle.h"
//Eigen
#include "GeoPrimitives/GeoPrimitives.h"
// TrkGeometry
#include "TrkGeometry/TrackingGeometry.h"
 
namespace Trk {
 
    class IMaterialMapper;
    class TrackingVolume;
    class Surface;
 
    typedef std::pair<Amg::Vector3D, const Trk::TrackingVolume*> PositionAtBoundary;

 
 
    // exit the volume
    struct VolumeExit {
        // the triple struct
        const Trk::TrackingVolume* nVolume;
        const Trk::Surface*        bSurface;
        Amg::Vector3D              vExit;
        
        VolumeExit( const Trk::TrackingVolume* itv = 0,
                    const Trk::Surface* ibs = 0,
                    Amg::Vector3D iexit = Amg::Vector3D(0.,0.,0.)) :
          nVolume(itv),
          bSurface(ibs),
          vExit(iexit){}
    
    };
 
    class MaterialValidation : public AthAlgorithm {
 
      public:

        MaterialValidation(const std::string& name, ISvcLocator* pSvcLocator);
        ~MaterialValidation();

        StatusCode          initialize();
        
        StatusCode          execute();
        
        StatusCode          finalize();
 
      private:
        PositionAtBoundary collectMaterialAndExit(const Trk::TrackingVolume& tvol, 
                                                  const Amg::Vector3D& position, 
                                                  const Amg::Vector3D& direction);
          
        const TrackingGeometry& trackingGeometry() const;
 
        void throwFailedToGetTrackingGeometry() const;
        const TrackingGeometry* retrieveTrackingGeometry(
          const EventContext& ctx) const
        {
          SG::ReadCondHandle<TrackingGeometry> handle(m_trackingGeometryReadKey,
                                                      ctx);
          if (!handle.isValid()) {
            ATH_MSG_FATAL("Could not load TrackingGeometry with name '"
                          << m_trackingGeometryReadKey.key() << "'. Aborting.");
            throwFailedToGetTrackingGeometry();
          }
          return handle.cptr();
        }
 
        SG::ReadCondHandleKey<TrackingGeometry>   m_trackingGeometryReadKey
           {this, "TrackingGeometryReadKey", "", "Key of the TrackingGeometry conditions data."};
                                  
        ToolHandle<IMaterialMapper>                          m_materialMapper;            
        int                                                  m_maxMaterialValidationEvents;  
        
 
        Rndm::Numbers*                                       m_flatDist;                   
        double                                               m_etaMin;                     
        double                                               m_etaMax;                     
        bool                                                 m_runNativeNavigation;        
        
        double                                               m_accTinX0;                   
        
    };
    
    inline const Trk::TrackingGeometry& Trk::MaterialValidation::trackingGeometry() const {
       const Trk::TrackingGeometry *tracking_geometry = retrieveTrackingGeometry(Gaudi::Hive::currentContext());
       if (!tracking_geometry){
          ATH_MSG_FATAL("Did not get valid TrackingGeometry. Aborting." );
          throw GaudiException("MaterialValidation", "Problem with TrackingGeometry loading.", StatusCode::FAILURE);
       }
       return *tracking_geometry;
    }
}
 
#endif