VXDDedxTrack.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 <reconstruction/dataobjects/DedxConstants.h>
#include <framework/datastore/RelationsObject.h>
#include <framework/gearbox/Const.h>
 
#include <vector>
#include <TH2F.h>
 
namespace Belle2 {
  class VXDDedxTrack : public RelationsObject {
    friend class VXDDedxPIDModule;
 
  public:
 
    VXDDedxTrack() = default;
 
    void addHit(int sid, int layer, int adcCount, double dx, double dEdx);
 
    void addDedx(int layer, double distance, double dedxValue);
 
    double getDedx(Const::EDetector detector) const;
 
    double getDedxError(Const::EDetector detector) const;
 
    double getDedxMean(Const::EDetector detector) const;
 
    int eventID() const { return m_eventID; }
 
    int trackID() const { return m_trackID; }
 
    double getCosTheta() const { return m_cosTheta; }
 
    double getMomentum() const { return m_p; }
 
    double getTrueMomentum() const { return m_pTrue; }
 
    int size() const { return m_nHits; }
 
    int getNHitsUsed() const { return m_nHitsUsed; }
 
    int getLayer(int i) const { return m_layer[i]; }
 
    int getSensorID(int i) const { return m_sensorID[i]; }
 
    int getADCCount(int i) const { return m_adcCount[i]; }
 
    double getDx(int i) const { return m_dx[i]; }
 
    double getDedxOfHit(int i) const { return m_dEdx[i]; }
 
    const std::vector<double>& getDedxList() const { return m_dEdx; }
 
    void clearLogLikelihoods();
 
    void addLogLikelihoods(const std::vector<const TH2F*>& PDFs, Dedx::Detector detector, bool truncated);
 
    bool areLogLikelihoodsAvailable() const {return m_numAdded > 0;}
 
    const double* getLogLikelihoods() const {return m_vxdLogl;}
 
  private:
 
    void addLogLikelihoods(const std::vector<const TH2F*>& PDFs, double dedxValue, double minPDFValue);
 
    // hit level information
    std::vector<int> m_layer;    
    std::vector<int> m_sensorID; 
    std::vector<int> m_adcCount; 
    std::vector<double> m_dx;    
    std::vector<double> m_dEdx;  
    // one entry per layer (just don't mix with the hit arrays)
    std::vector<double> dedx;      
    std::vector<double> dist;      
    std::vector<double> dedxLayer; 
    double m_vxdLogl[Const::ChargedStable::c_SetSize] = {0}; 
    // dEdx information
    double m_dedxAvg[2] = {0};            
    double m_dedxAvgTruncated[2] = {0};   
    double m_dedxAvgTruncatedErr[2] = {0}; 
    // track level information
    double m_p = 0;        
    double m_cosTheta = 0; 
    double m_length = 0;   
    short m_charge = 0;    
    // MC information
    double m_pdg = 0;       
    double m_motherPDG = 0; 
    double m_pTrue = 0;     
    int m_numAdded = 0; 
    int m_eventID = 0; 
    int m_trackID = 0; 
    short m_nHits = 0;     
    short m_nHitsUsed = 0; 
    ClassDef(VXDDedxTrack, 4); 
  };
}