MaterialMapper.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
// MaterialMapper.h, (c) ATLAS Detector software
 
#ifndef TRKDETDESCRTOOLS_MATERIALMAPPER_H
#define TRKDETDESCRTOOLS_MATERIALMAPPER_H
 
// Amg
#include "GeoPrimitives/GeoPrimitives.h"
// Gaudi & Athena
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/IIncidentListener.h"
// Trk
#include "TrkDetDescrInterfaces/IMaterialMapper.h"
// ROOT
#include "TTree.h"
#include "TString.h"
#include "CxxUtils/checker_macros.h"
 
#define TRKDETDESCRTOOLS_MAXSTEPS 8000
#define TRKDETDESCRTOOLS_MAXLAYERHITS 5000
 
class TTree;
 
namespace Trk {
 
    class TrackingVolume;
    class Layer;
 
 
    struct VolumeTreeObject {
        VolumeTreeObject (const VolumeTreeObject&) = delete;
        VolumeTreeObject& operator= (const VolumeTreeObject&) = delete;
 
        float eta;
        float phi;
        float path;
        float pathInX0;
        float pathInL0;
        float pathZARho;
        TTree* tree;
 
        VolumeTreeObject(TString name, TString title)
        : eta(0),
          phi(0.),
          path(0.),
          pathInX0(0.),
          pathInL0(0.),
          pathZARho(0.),
          tree(new TTree(name,title))
        {
            tree->Branch("Eta",             &eta,           "eta/F");
            tree->Branch("Phi",             &phi,           "phi/F");
            tree->Branch("Path",            &path,          "path/F");
            tree->Branch("PathInX0",        &pathInX0,      "pathX0/F");
            tree->Branch("PathInL0",        &pathInL0,      "pathL0/F");
            tree->Branch("PathZARho",       &pathZARho,  "pathZARho/F");
        }
    };
 
    struct LayerTreeObject {
        LayerTreeObject (const LayerTreeObject&) = delete;
        LayerTreeObject& operator= (const LayerTreeObject&) = delete;
 
        // values for the full histo
        float densedHitX;
        float densedHitY;
        float densedHitZ;
        float densedHitR;
        float densedHitPhi;
        float densedHitTheta;
        int   densedHits;
 
        float correctionFactor;
        float path;
        float pathInX0;
        float pathInL0;
        float A;
        float Z;
        float rho;
 
        int   layerHits;
        float hitPathInX0[TRKDETDESCRTOOLS_MAXLAYERHITS];
        float hitPositionX[TRKDETDESCRTOOLS_MAXLAYERHITS];
        float hitPositionY[TRKDETDESCRTOOLS_MAXLAYERHITS];
        float hitPositionZ[TRKDETDESCRTOOLS_MAXLAYERHITS];
        float hitPositionR[TRKDETDESCRTOOLS_MAXLAYERHITS];
        float hitPositionEta[TRKDETDESCRTOOLS_MAXLAYERHITS];
 
        TTree* tree;
 
        LayerTreeObject(TString name, TString title)
        : densedHitX(0.),
          densedHitY(0.),
          densedHitZ(0.),
          densedHitR(0.),
          densedHitPhi(0.),
          densedHitTheta(0.),
          densedHits(0),
          correctionFactor(0.),
          path(0.),
          pathInX0(0.),
          pathInL0(0.),
          A(0.),
          Z(0.),
          rho(0.),
          layerHits(0),
          tree(new TTree(name,title))
        {
            tree->Branch("DensedHits",       &densedHits,        "densedHits/I");
            tree->Branch("DensedHitX",       &densedHitX,        "densedHitX/F");
            tree->Branch("DensedHitY",       &densedHitY,        "densedHitY/F");
            tree->Branch("DensedHitZ",       &densedHitZ,        "densedHitZ/F");
            tree->Branch("DensedHitR",       &densedHitR,        "densedHitR/F");
            tree->Branch("DensedHitPhi",     &densedHitPhi,      "densedHitPhi/F");
            tree->Branch("DensedHitTheta",   &densedHitTheta,    "densedHitTheta/F");
 
            tree->Branch("CorrFactor",       &correctionFactor,  "corrF/F");
            tree->Branch("Path",             &path,              "pathInX0/F");
            tree->Branch("PathInX0",         &pathInX0,          "pathInX0/F");
            tree->Branch("PathInL0",         &pathInL0,          "pathInL0/F");
            tree->Branch("A",                &A,                 "a/F");
            tree->Branch("Z",                &Z,                 "z/F");            
            tree->Branch("Rho",              &rho,               "rho/F");
            tree->Branch("Hits",             &layerHits,         "layerhits/I");
            tree->Branch("HitPathInX0",      &hitPathInX0,       "layerhitpathInX0[layerhits]/F");
            tree->Branch("HitPositionX",     &hitPositionX,      "layerhitsX[layerhits]/F");
            tree->Branch("HitPositionY",     &hitPositionY,      "layerhitsY[layerhits]/F");
            tree->Branch("HitPositionZ",     &hitPositionZ,      "layerhitsZ[layerhits]/F");
            tree->Branch("HitPositionR",     &hitPositionR,      "layerhitsR[layerhits]/F");
            tree->Branch("HitPositionEta",   &hitPositionEta,    "layerhitsR[layerhits]/F");
        }
    };
 
 
    struct SurfaceTreeObject {
        SurfaceTreeObject (const SurfaceTreeObject&) = delete;
        SurfaceTreeObject& operator= (const SurfaceTreeObject&) = delete;
 
        float loc1;
        float loc2;
        float eta;
        float correctionFactor;
        float path;
        float pathInX0;
        float pathInL0;
        float A;
        float Z;
        float rho;
 
        int    surfaceHits;
        TTree* tree;
 
        SurfaceTreeObject(TString name, TString title)
        : loc1(0.),
          loc2(0.),
          eta(0.),
          correctionFactor(0.),
          path(0.),
          pathInX0(0.),
          pathInL0(0.),
          A(0.),
          Z(0.),
          rho(0.),
          surfaceHits(0),
          tree(new TTree(name,title))
        {
            tree->Branch("Local1",           &loc1,              "local1/F");
            tree->Branch("Local2",           &loc2,              "local2/F");
            tree->Branch("Eta",              &eta,               "eta/F");
            tree->Branch("CorrFactor",       &correctionFactor,  "corrF/F");
            tree->Branch("Path",             &path,              "path/F");
            tree->Branch("PathInX0",         &pathInX0,          "pathInX0/F");
            tree->Branch("PathInL0",         &pathInL0,          "pathInL0/F");
            tree->Branch("A",                &A,                 "a/F");
            tree->Branch("Z",                &Z,                 "z/F");            
            tree->Branch("Rho",              &rho,               "rho/F");
        }
    };
 
 
    class ATLAS_NOT_THREAD_SAFE MaterialMapper : //mutable
      public AthAlgTool, virtual public IMaterialMapper, virtual public IIncidentListener {
 
      public:
 
        MaterialMapper(const std::string&,
                       const std::string&,
                       const IInterface*);
 
        virtual ~MaterialMapper();
 
        StatusCode initialize();
        
        StatusCode finalize();
 
        void recordMaterialHit(const AssociatedMaterial& amhit, const Amg::Vector3D& projectedPosition) const;
 
        void recordLayerHit(const AssociatedMaterial& amhit, bool full = false) const;
 
        void recordSurfaceHit(const Amg::Vector2D& locpos, const AssociatedMaterial& amhit) const;
 
        void handle( const Incident& inc );
 
      private:
          
        void finalizeVolumeHits(bool mapped=true) const;
 
        void finalizeLayerHits() const;
 
        void finalizeSurfaceHits() const;
 
        void bookValidationTree();
 
        VolumeTreeObject* volumeTreeObject(const Layer* lay=0, const TrackingVolume* tvol=0) const;
 
        LayerTreeObject* layerTreeObject(const Layer& lay, bool full = false) const;
 
        SurfaceTreeObject* surfaceTreeObject(const Layer& lay) const;
 
 
        /* Incident Service */ 
        ServiceHandle<IIncidentSvc>          m_incidentSvc; 
 
        int                   m_materialAssociationType;
 
        // (1) ------------------------- Tree name of the total material statistics
        unsigned int          m_maxMappingEvents;
        mutable unsigned int  m_processedEvents;
        
        std::string           m_totalMaterialTree;
 
        // (2) ------------------------  Ntuple output of material effects validation
        TTree*                m_validationTree;            
        std::string           m_validationTreeName;        
        std::string           m_validationTreeDescription; 
        std::string           m_validationTreeFolder;      
 
 
        // Spatial information
        mutable int           m_materialSteps;                                          
        mutable float         m_averageEta;                                             
        mutable float         m_averagePhi;                                             
        mutable float         m_mappedPath;                                             
        mutable float         m_mappedPathInX0;                                         
        mutable float         m_mappedPathInL0;                                         
        mutable float         m_mappedPathRho;                                          
        mutable float         m_mappedPathZARho;                                        
        mutable float         m_unmappedPathInX0;                                       
        mutable int           m_mapped[TRKDETDESCRTOOLS_MAXSTEPS]{};                      
        mutable float         m_materialAccumPathInX0[TRKDETDESCRTOOLS_MAXSTEPS]{};       
        mutable float         m_materialAccumPathZARho[TRKDETDESCRTOOLS_MAXSTEPS]{};      
        mutable float         m_materialStepPath[TRKDETDESCRTOOLS_MAXSTEPS]{};            
        mutable float         m_materialStepX0[TRKDETDESCRTOOLS_MAXSTEPS]{};              
        mutable float         m_materialStepL0[TRKDETDESCRTOOLS_MAXSTEPS]{};              
        mutable float         m_materialStepZ[TRKDETDESCRTOOLS_MAXSTEPS]{};               
        mutable float         m_materialStepA[TRKDETDESCRTOOLS_MAXSTEPS]{};               
        mutable float         m_materialStepRho[TRKDETDESCRTOOLS_MAXSTEPS]{};             
        mutable float         m_materialStepPositionX[TRKDETDESCRTOOLS_MAXSTEPS]{};       
        mutable float         m_materialStepPositionY[TRKDETDESCRTOOLS_MAXSTEPS]{};       
        mutable float         m_materialStepPositionZ[TRKDETDESCRTOOLS_MAXSTEPS]{};       
        mutable float         m_materialStepPositionR[TRKDETDESCRTOOLS_MAXSTEPS]{};       
        mutable float         m_materialProjPositionX[TRKDETDESCRTOOLS_MAXSTEPS]{};       
        mutable float         m_materialProjPositionY[TRKDETDESCRTOOLS_MAXSTEPS]{};       
        mutable float         m_materialProjPositionZ[TRKDETDESCRTOOLS_MAXSTEPS]{};       
        mutable float         m_materialProjPositionR[TRKDETDESCRTOOLS_MAXSTEPS]{};       
        mutable float         m_materialProjDistance[TRKDETDESCRTOOLS_MAXSTEPS]{};        
 
        // Per Volume Validation
        bool                  m_volumeValidation;
        std::string           m_volumeTreePrefix;
        mutable std::map< const Trk::TrackingVolume*, VolumeTreeObject* > m_volumeTrees;
        mutable std::map< const Trk::TrackingVolume*, VolumeTreeObject* > m_volumeTreesUnmapped;
 
        // Per Layer Validation
        bool                  m_layerValidation;
        std::string           m_layerTreePrefix;
        mutable std::map< const Trk::Layer*, LayerTreeObject* >           m_layerTrees;
        mutable std::map< const Trk::Layer*, LayerTreeObject* >           m_layerFullTrees;
 
        // Per Surface Validation
        bool                  m_surfaceValidation;
        std::string           m_surfaceTreePrefix;
        mutable std::map< const Trk::Layer*, SurfaceTreeObject* >         m_surfaceTrees;
 
    };
 
} // end of namespace
 
#endif // TRKDETDESCRTOOLS_MATERIALMAPPER_H