TrackParticleAuxContainer_v4.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
// $Id: TrackParticleAuxContainer_v4.h $
#ifndef XAODTRACKING_VERSIONS_TRACKPARTICLEAUXCONTAINER_V4_H
#define XAODTRACKING_VERSIONS_TRACKPARTICLEAUXCONTAINER_V4_H
 
// System include(s):
extern "C" {
#   include <stdint.h>
}
#include <vector>
 
// EDM include(s):
#include "xAODCore/AuxContainerBase.h"
#include "AthLinks/ElementLink.h"
 
// Local include(s):
#include "xAODTracking/VertexContainer.h"
 
// Want to be able to switch this off and on for the moment
//#define XAODTRACKING_SUMMARYDYNAMIC
 
namespace xAOD {

   class TrackParticleAuxContainer_v4 : public AuxContainerBase {
 
   public:
      TrackParticleAuxContainer_v4();
      void dump() const;
      void toTransient();
      using AuxContainerBase::toTransient;
 
   private:

      std::vector< float >                d0;
      std::vector< float >                z0;
      std::vector< float >                phi;
      std::vector< float >                theta;
      std::vector< float >                qOverP;
 
      std::vector< std::vector<float> >   definingParametersCovMatrix;
 
      std::vector< float >                vx;
      std::vector< float >                vy;
      std::vector< float >                vz;
 
      // /// @name Parameters
//       /// We store the 3-pos, 3-mom and charge, and on the transient side these will be transformed into curvilinear parameters.
//       /// Also stored are the cov matrix (still expressed in local coordinate frame) and parameter position.
//       /// @{
//       std::vector< std::vector<float> >   parameterX;
//       std::vector< std::vector<float> >   parameterY;
//       std::vector< std::vector<float> >   parameterZ;
//       std::vector< std::vector<float> >   parameterPX;
//       std::vector< std::vector<float> >   parameterPY;
//       std::vector< std::vector<float> >   parameterPZ;
//       // std::vector< char > charge; /// @todo Is this really necessary? Can get it from qOverP?
//
//       std::vector< std::vector<float> >   trackParameterCovarianceMatrices;
//       std::vector< std::vector<uint8_t> > parameterPosition;
 
      std::vector< float >                radiusOfFirstHit;
      std::vector< uint64_t >             identifierOfFirstHit;
 
     std::vector< float >  beamlineTiltX; 
     std::vector< float >  beamlineTiltY;
 
     std::vector< uint32_t > hitPattern;

      std::vector< float >                chiSquared;
      std::vector< float >                numberDoF;

      std::vector< uint8_t >              trackFitter;
      std::vector< uint8_t >              particleHypothesis;
      std::vector< uint8_t >              trackProperties;
      std::vector< uint64_t >             patternRecoInfo;
 
#ifndef XAODTRACKING_SUMMARYDYNAMIC
     std::vector< uint8_t >         numberOfContribPixelLayers       ;
     std::vector< uint8_t >         numberOfInnermostPixelLayerHits               ;
     std::vector< uint8_t >         numberOfInnermostPixelLayerOutliers           ;
     std::vector< uint8_t >         numberOfInnermostPixelLayerSharedHits         ;
     std::vector< uint8_t >         numberOfInnermostPixelLayerSplitHits          ;
     std::vector< uint8_t >         expectInnermostPixelLayerHit                  ; 
     std::vector< uint8_t >         numberOfNextToInnermostPixelLayerHits               ;
     std::vector< uint8_t >         numberOfNextToInnermostPixelLayerOutliers           ;
     std::vector< uint8_t >         numberOfNextToInnermostPixelLayerSharedHits         ;
     std::vector< uint8_t >         numberOfNextToInnermostPixelLayerSplitHits          ;
     std::vector< uint8_t >         expectNextToInnermostPixelLayerHit                  ; 
     std::vector< uint8_t >         numberOfPixelHits                ;
     std::vector< uint8_t >         numberOfPixelOutliers            ;
     std::vector< uint8_t >         numberOfPixelHoles               ;
     std::vector< uint8_t >         numberOfPixelSharedHits          ;
     std::vector< uint8_t >         numberOfPixelSplitHits           ;
     std::vector< uint8_t >         numberOfGangedPixels             ;
     std::vector< uint8_t >         numberOfGangedFlaggedFakes       ;
     std::vector< uint8_t >         numberOfPixelDeadSensors         ;
     std::vector< uint8_t >         numberOfPixelSpoiltHits          ;
     std::vector< uint8_t >         numberOfDBMHits                  ;
     std::vector< uint8_t >         numberOfSCTHits                  ;
     std::vector< uint8_t >         numberOfSCTOutliers              ;
     std::vector< uint8_t >         numberOfSCTHoles                 ;
     std::vector< uint8_t >         numberOfSCTDoubleHoles           ;
     std::vector< uint8_t >         numberOfSCTSharedHits            ;
     std::vector< uint8_t >         numberOfSCTDeadSensors           ;
     std::vector< uint8_t >         numberOfSCTSpoiltHits            ;
     std::vector< uint8_t >         numberOfTRTHits                  ;
     std::vector< uint8_t >         numberOfTRTOutliers              ;
     std::vector< uint8_t >         numberOfTRTHoles                 ;
     std::vector< uint8_t >         numberOfTRTHighThresholdHits     ;
     std::vector< uint8_t >         numberOfTRTHighThresholdHitsTotal;
     std::vector< uint8_t >         numberOfTRTHighThresholdOutliers ;
     std::vector< uint8_t >         numberOfTRTDeadStraws            ;
     std::vector< uint8_t >         numberOfTRTTubeHits              ;
     std::vector< uint8_t >         numberOfTRTXenonHits             ;
     std::vector< uint8_t >         numberOfTRTSharedHits             ;
     
     std::vector< uint8_t >         numberOfPrecisionLayers;
     std::vector< uint8_t >         numberOfPrecisionHoleLayers;
     std::vector< uint8_t >         numberOfPhiLayers;
     std::vector< uint8_t >         numberOfPhiHoleLayers;
     std::vector< uint8_t >         numberOfTriggerEtaLayers;
     std::vector< uint8_t >         numberOfTriggerEtaHoleLayers;
     
     std::vector< uint8_t >         numberOfOutliersOnTrack          ;
     std::vector< uint8_t >         standardDeviationOfChi2OS        ;
     std::vector< float >           eProbabilityComb;
     std::vector< float >           eProbabilityHT;
     //     std::vector< float >           eProbabilityToT;
     //     std::vector< float >           eProbabilityBrem;
     std::vector< float >           pixeldEdx;
     std::vector< uint8_t >         numberOfUsedHitsdEdx;
     std::vector< uint8_t >         numberOfIBLOverflowsdEdx;

#endif


     std::vector< float> TRTTrackOccupancy;
 
   }; // class TrackParticleAuxContainer_v4
 
} // namespace xAOD
 
#include "xAODCore/BaseInfo.h"
SG_BASE( xAOD::TrackParticleAuxContainer_v4, xAOD::AuxContainerBase );
 
#endif // XAODTRACKING_VERSIONS_TRACKPARTICLEAUXCONTAINER_V4_H