PXDPerformanceStructs.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <framework/gearbox/Unit.h>
#include <framework/gearbox/Const.h>
#include <framework/datastore/RelationsObject.h>
#include <pxd/dataobjects/PXDCluster.h>
#include <tracking/dataobjects/RecoTrack.h>
#include <tracking/dataobjects/PXDIntercept.h>
#include <genfit/MeasuredStateOnPlane.h>
#include <TVector3.h>
//#include <limits>
#include <vector>
#include <math.h>
 
#include <pxd/utilities/PXDUtilities.h>
#include <mdst/dataobjects/Track.h>
#include <mdst/dataobjects/HitPatternCDC.h>
#include <mdst/dataobjects/HitPatternVXD.h>
 
namespace Belle2 {
  namespace PXD {
 
    struct Cluster_t {
 
      Cluster_t(): pxdID(0), charge(0), size(0),
        uSize(0), vSize(0), posU(0.0), posV(0.0) {}
 
      void setValues(const PXDCluster& pxdCluster);
 
      unsigned short pxdID;     
      unsigned short charge; 
      unsigned short size;   
      unsigned short uSize;  
      unsigned short vSize;  
      float posU;            
      float posV;            
    }; // end struct Cluster_t
 
    struct TrackPoint_t {
 
      TrackPoint_t(): x(0.0), y(0.0), z(0.0),
        tol(0.0), chargeMPV(0.0), inside(false) {}
 
      RecoTrack* setValues(const PXDIntercept& pxdIntercept, const std::string& recoTracksName = "",
                           const double& mass = Const::electronMass);
 
      float x;         
      float y;         
      float z;         
      float tol;       
      float chargeMPV; 
      bool inside; 
    }; // end struct TrackPoint_t
 
    struct TrackCluster_t {
      TrackCluster_t(): usedInTrack(false), dU(INFINITY), dV(INFINITY) {}
 
      RecoTrack* setValues(const PXDIntercept& pxdIntercept,
                           const std::string& recoTracksName = "",
                           const std::string& pxdTrackClustersName = "PXDClustersFromTracks",
                           const double& mass = Const::electronMass);
 
      bool usedInTrack;        
      float dU;                
      float dV;                
      Cluster_t cluster;         
      TrackPoint_t intersection; 
    }; // end struct TrackCluster_t
 
    template <typename TTrackCluster>
    struct TrackBase_t {
      TrackBase_t(): d0(0.0), z0(0.0), phi0(0.0), pt(0.0), tanLambda(0.0),
        d0p(0.0), z0p(0.0), nPXDHits(0), nSVDHits(0), nCDCHits(0) {}
 
      void setTrackVariables(const TrackFitResult* tfrPtr, const TVector3& ip);
 
      void setValues(const RecoTrack& recoTrack, const TVector3& ip = TVector3(0, 0, 0),
                     const std::string& recoTracksName = "",
                     const std::string& pxdInterceptsName = "",
                     const std::string& pxdTrackClustersName = "PXDClustersFromTracks"
                    );
 
      float d0;        
      float z0;        
      float phi0;      
      float pt;        
      float tanLambda; 
      float d0p;       
      float z0p;       
      unsigned short nPXDHits; 
      unsigned short nSVDHits; 
      unsigned short nCDCHits; 
      std::vector<TTrackCluster> trackClusters; 
    };
 
    typedef TrackBase_t<TrackCluster_t> Track_t;
 
 
    template <typename TTrackCluster>
    void TrackBase_t<TTrackCluster>::setTrackVariables(
      const TrackFitResult* tfrPtr, const TVector3& ip
    )
    {
      if (!tfrPtr) {
        B2ERROR("Expect the track fit result. Found Nothing!");
      }
      nCDCHits = tfrPtr->getHitPatternCDC().getNHits();
      nSVDHits = tfrPtr->getHitPatternVXD().getNSVDHits();
      nPXDHits = tfrPtr->getHitPatternVXD().getNPXDHits();
      tanLambda = tfrPtr->getCotTheta();
      pt = tfrPtr->getMomentum().Perp();
      d0 = tfrPtr->getD0();
      z0 = tfrPtr->getZ0();
      phi0 = tfrPtr->getPhi0();
      d0p = d0;
      z0p = z0;
      if (ip != TVector3(0, 0, 0)) {
        // get a helix and change coordinate origin to ip
        auto uHelix = tfrPtr->getUncertainHelix();
        uHelix.passiveMoveBy(ip);
        d0p = uHelix.getD0();
        z0p = uHelix.getZ0();
      }
    }
 
    template <typename TTrackCluster>
    void TrackBase_t<TTrackCluster>::setValues(
      const RecoTrack& recoTrack, const TVector3& ip,
      const std::string& recoTracksName,
      const std::string& pxdInterceptsName,
      const std::string& pxdTrackClustersName
    )
    {
      // get Track pointer
      auto trackPtr = recoTrack.getRelated<Track>("Tracks");
      if (!trackPtr) {
        B2ERROR("Expect a track for fitted recotracks. Found nothing!");
      }
 
      // get trackFitResult pointer
      auto tfrPtr = trackPtr->getTrackFitResultWithClosestMass(
                      Const::pion); // always try to use pion as electron fit doesn't work properly.
      setTrackVariables(tfrPtr, ip);
 
      //RelationVector<PXDIntercept> pxdIntercepts = recoTrack.getRelationsTo<PXDIntercept>();
      auto pxdIntercepts = recoTrack.getRelationsTo<PXDIntercept>(pxdInterceptsName);
      for (auto& pxdIntercept : pxdIntercepts) {
        TTrackCluster temp;
        // Only push a TrackCluster when setValues succeeds
        if (temp.setValues(pxdIntercept, recoTracksName, pxdTrackClustersName))
          trackClusters.push_back(temp);
      }
    }
 
    //} // end namespace Tuple
  } // end namespace PXD
} // end namespace Belle2